/**
 * opcodes.c
 * Implementation of the opcode declarations found in opcodes.h
 *
 * @author  Philippe Johnson
 */

#ifdef _MSC_VER

#pragma warning(disable:4244) /* Converstion from 'u16' to 'u8'... */
#pragma warning(disable:4333) /* Right shift by too large amount, data loss */
#pragma warning(disable:4312) /* Conversion from 'int' to 'u8*'... */

#endif

#include "common.h"

#include "65c816.h"
#include "opcodes.h"
#include "cpuhelpers.h"
#include "memory.h"

/** ADC - Add with carry **/
/* 0x69 */
void adc69M() {
    u8 data = memRead8NoTrap(amImmediate());
    ADC8(data);
    
    updateCyclesByOpcodeMX(0x69);
    updatePCByOpcodeMX(0x69);
}

void adc69m() {
    u16 data = memRead16NoTrap(amImmediate());
    ADC16(data);

    updateCyclesByOpcodemX(0x69);
    updatePCByOpcodemX(0x69);
}

/* 0x6D */
void adc6DM() {
    u8 data = memRead8NoTrap(amAbsolute());
    ADC8(data);

    updateCyclesByOpcodeMX(0x6D);
    updatePCByOpcodeMX(0x6D);
}

void adc6Dm() {
    u16 data = memRead16NoTrap(amAbsolute());
    ADC16(data);

    updateCyclesByOpcodemX(0x6D);
    updatePCByOpcodemX(0x6D);
}

/* 0x6F */
void adc6FM() {
    u8 data = memRead8NoTrap(amAbsoluteLong());
    ADC8(data);

    updateCyclesByOpcodeMX(0x6F);
    updatePCByOpcodeMX(0x6F);
}

void adc6Fm() {
    u16 data = memRead16NoTrap(amAbsoluteLong());
    ADC16(data);

    updateCyclesByOpcodemX(0x6F);
    updatePCByOpcodemX(0x6F);
}

/* 0x65 */
void adc65M() {
    u8 data = memRead8NoTrap(amDirectPage());
    ADC8(data);

    updateCyclesByOpcodeMX(0x65);
    updatePCByOpcodeMX(0x65);
}

void adc65m() {
    u16 data = memRead16NoTrap(amDirectPage());
    ADC16(data);

    updateCyclesByOpcodemX(0x65);
    updatePCByOpcodemX(0x65);
}

/* 0x72 */
void adc72M() {
    u8 data = memRead8NoTrap(amDirectPageIndirect());
    ADC8(data);

    updateCyclesByOpcodeMX(0x72);
    updatePCByOpcodeMX(0x72);
}

void adc72m() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    ADC16(data);

    updateCyclesByOpcodemX(0x72);
    updatePCByOpcodemX(0x72);
}

/* 0x67 */
void adc67M() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    ADC8(data);

    updateCyclesByOpcodeMX(0x67);
    updatePCByOpcodeMX(0x67);
}

void adc67m() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    ADC16(data);

    updateCyclesByOpcodemX(0x67);
    updatePCByOpcodemX(0x67);
}

/* 0x7D */
void adc7DMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    ADC8(data);

    updateCyclesByOpcodeMX(0x7D);
    updatePCByOpcodeMX(0x7D);
}

void adc7DmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    ADC16(data);

    updateCyclesByOpcodemX(0x7D);
    updatePCByOpcodemX(0x7D);
}

void adc7DMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    ADC8(data);

    updateCyclesByOpcodeMx(0x7D);
    updatePCByOpcodeMx(0x7D);
}

void adc7Dmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    ADC16(data);

    updateCyclesByOpcodemx(0x7D);
    updatePCByOpcodemx(0x7D);
}

/* 0x7F */
void adc7FMX() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX8());
    ADC8(data);

    updateCyclesByOpcodeMX(0x7F);
    updatePCByOpcodeMX(0x7F);
}

void adc7FmX() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX8());
    ADC16(data);

    updateCyclesByOpcodemX(0x7F);
    updatePCByOpcodemX(0x7F);
}

void adc7FMx() {
    u8 data = memRead16NoTrap(amAbsoluteLongIndexX16());
    ADC8(data);

    updateCyclesByOpcodeMx(0x7F);
    updatePCByOpcodeMx(0x7F);
}

void adc7Fmx() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX16());
    ADC16(data);

    updateCyclesByOpcodemx(0x7F);
    updatePCByOpcodemx(0x7F);
}

/* 0x79 */
void adc79MX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    ADC8(data);

    updateCyclesByOpcodeMX(0x79);
    updatePCByOpcodeMX(0x79);
}

void adc79mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    ADC16(data);

    updateCyclesByOpcodemX(0x79);
    updatePCByOpcodemX(0x79);
}

void adc79Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    ADC8(data);

    updateCyclesByOpcodeMx(0x79);
    updatePCByOpcodeMx(0x79);
}

void adc79mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    ADC16(data);

    updateCyclesByOpcodemx(0x79);
    updatePCByOpcodemx(0x79);
}

/* 0x75 */
void adc75MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    ADC8(data);

    updateCyclesByOpcodeMX(0x75);
    updatePCByOpcodeMX(0x75);
}

void adc75mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexX8());
    ADC16(data);

    updateCyclesByOpcodemX(0x75);
    updatePCByOpcodemX(0x75);
}

void adc75Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexX16());
    ADC8(data);

    updateCyclesByOpcodeMx(0x75);
    updatePCByOpcodeMx(0x75);
}

void adc75mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexX16());
    ADC16(data);

    updateCyclesByOpcodemx(0x75);
    updatePCByOpcodemx(0x75);
}

/* 0x61 */
void adc61MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    ADC8(data);

    updateCyclesByOpcodeMX(0x61);
    updatePCByOpcodeMX(0x61);
}

void adc61mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    ADC16(data);

    updateCyclesByOpcodemX(0x61);
    updatePCByOpcodemX(0x61);
}

void adc61Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    ADC8(data);

    updateCyclesByOpcodeMx(0x61);
    updatePCByOpcodeMx(0x61);
}

void adc61mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    ADC16(data);

    updateCyclesByOpcodemx(0x61);
    updatePCByOpcodemx(0x61);
}

/* 0x71 */
void adc71MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectY8());
    ADC8(data);

    updateCyclesByOpcodeMX(0x71);
    updatePCByOpcodeMX(0x71);
}

void adc71mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectY8());
    ADC16(data);

    updateCyclesByOpcodemX(0x71);
    updatePCByOpcodemX(0x71);
}

void adc71Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectY16());
    ADC8(data);

    updateCyclesByOpcodeMx(0x71);
    updatePCByOpcodeMx(0x71);
}

void adc71mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectY16());
    ADC16(data);

    updateCyclesByOpcodemx(0x71);
    updatePCByOpcodemx(0x71);
}

/* 0x77 */
void adc77MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY8());
    ADC8(data);

    updateCyclesByOpcodeMX(0x77);
    updatePCByOpcodeMX(0x77);
}

void adc77mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY8());
    ADC16(data);

    updateCyclesByOpcodemX(0x77);
    updatePCByOpcodemX(0x77);
}

void adc77Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY16());
    ADC8(data);

    updateCyclesByOpcodeMx(0x77);
    updatePCByOpcodeMx(0x77);
}

void adc77mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY16());
    ADC16(data);

    updateCyclesByOpcodemx(0x77);
    updatePCByOpcodemx(0x77);
}

/* 0x63 */
void adc63M() {
    u8 data = memRead8NoTrap(amStackRelative());
    ADC8(data);

    updateCyclesByOpcodeMX(0x63);
    updatePCByOpcodeMX(0x63);
}

void adc63m() {
    u16 data = memRead16NoTrap(amStackRelative());
    ADC16(data);

    updateCyclesByOpcodemX(0x63);
    updatePCByOpcodemX(0x63);
}

/* 0x73 */
void adc73MX() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY8());
    ADC8(data);

    updateCyclesByOpcodeMX(0x73);
    updatePCByOpcodeMX(0x73);
}

void adc73mX() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY8());
    ADC16(data);

    updateCyclesByOpcodemX(0x73);
    updatePCByOpcodemX(0x73);
}

void adc73Mx() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY16());
    ADC8(data);

    updateCyclesByOpcodeMx(0x73);
    updatePCByOpcodeMx(0x73);
}

void adc73mx() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY16());
    ADC16(data);

    updateCyclesByOpcodemx(0x73);
    updatePCByOpcodemx(0x73);
}

/* AND - And accumulator with memory */
/* 0x29 */
void and29M() {
    u8 data = memRead8NoTrap(amImmediate());
    AND8(data);

    updateCyclesByOpcodeMX(0x29);
    updatePCByOpcodeMX(0x29);    
}

void and29m() {
    u16 data = memRead16NoTrap(amImmediate());
    AND16(data);

    updateCyclesByOpcodemx(0x29);
    updatePCByOpcodemx(0x29);
}

/* 0x2D */
void and2DM() {
    u8 data = memRead8NoTrap(amAbsolute());
    AND8(data);

    updateCyclesByOpcodeMX(0x2D);
    updatePCByOpcodeMX(0x2D);
}

void and2Dm() {
    u16 data = memRead16NoTrap(amAbsolute());
    AND16(data);

    updateCyclesByOpcodemx(0x2D);
    updatePCByOpcodemx(0x2D);
}

/* 0x2F */
void and2FM() {
    u8 data = memRead8NoTrap(amAbsoluteLong());
    AND8(data);

    updateCyclesByOpcodeMX(0x2F);
    updatePCByOpcodeMX(0x2F);
}

void and2Fm() {
    u16 data = memRead16NoTrap(amAbsoluteLong());
    AND16(data);

    updateCyclesByOpcodemx(0x2F);
    updatePCByOpcodemx(0x2F);
}

/* 0x25 */
void and25M() {
    u8 data = memRead8NoTrap(amDirectPage());
    AND8(data);

    updateCyclesByOpcodeMX(0x25);
    updatePCByOpcodeMX(0x25);
}

void and25m() {
    u16 data = memRead16NoTrap(amDirectPage());
    AND16(data);

    updateCyclesByOpcodemx(0x25);
    updatePCByOpcodemx(0x25);
}

/* 0x32 */
void and32M() {
    u8 data = memRead8NoTrap(amDirectPageIndirect());
    AND8(data);

    updateCyclesByOpcodeMX(0x32);
    updatePCByOpcodeMX(0x32);
}

void and32m() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    AND16(data);

    updateCyclesByOpcodemx(0x32);
    updatePCByOpcodemx(0x32);
}

/* 0x27 */
void and27M() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    AND8(data);

    updateCyclesByOpcodeMX(0x27);
    updatePCByOpcodeMX(0x27);
}

void and27m() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    AND16(data);

    updateCyclesByOpcodemx(0x27);
    updatePCByOpcodemx(0x27);
}

/* 0x3D */
void and3DMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    AND8(data);

    updateCyclesByOpcodeMX(0x3D);
    updatePCByOpcodeMX(0x3D);
}

void and3DmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    AND16(data);

    updateCyclesByOpcodemX(0x3D);
    updatePCByOpcodemX(0x3D);
}

void and3DMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    AND8(data);

    updateCyclesByOpcodeMx(0x3D);
    updatePCByOpcodeMx(0x3D);
}

void and3Dmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    AND16(data);

    updateCyclesByOpcodemx(0x3D);
    updatePCByOpcodemx(0x3D);
}

/* 0x3F */
void and3FMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    AND8(data);

    updateCyclesByOpcodeMX(0x3F);
    updatePCByOpcodeMX(0x3F);
}

void and3FmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    AND16(data);

    updateCyclesByOpcodemX(0x3F);
    updatePCByOpcodemX(0x3F);
}

void and3FMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    AND8(data);

    updateCyclesByOpcodeMx(0x3F);
    updatePCByOpcodeMx(0x3F);
}

void and3Fmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    AND16(data);

    updateCyclesByOpcodemx(0x3F);
    updatePCByOpcodemx(0x3F);
}

/* 0x39 */
void and39MX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    AND8(data);

    updateCyclesByOpcodeMX(0x39);
    updatePCByOpcodeMX(0x39);
}

void and39mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    AND16(data);

    updateCyclesByOpcodemX(0x39);
    updatePCByOpcodemX(0x39);
}

void and39Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    AND8(data);

    updateCyclesByOpcodeMx(0x39);
    updatePCByOpcodeMx(0x39);    
}

void and39mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    AND16(data);

    updateCyclesByOpcodemx(0x39);
    updatePCByOpcodemx(0x39);    
}

/* 0x35 */
void and35MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    AND8(data);

    updateCyclesByOpcodeMX(0x35);
    updatePCByOpcodeMX(0x35);        
}

void and35mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexX8());
    AND16(data);

    updateCyclesByOpcodemX(0x35);
    updatePCByOpcodemX(0x35);     
}

void and35Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexX16());
    AND8(data);

    updateCyclesByOpcodeMx(0x35);
    updatePCByOpcodeMx(0x35);     
}

void and35mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexX16());
    AND16(data);

    updateCyclesByOpcodemx(0x35);
    updatePCByOpcodemx(0x35); 
}

/* 0x21 */
void and21MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    AND8(data);

    updateCyclesByOpcodeMX(0x21);
    updatePCByOpcodeMX(0x21);     
}

void and21mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    AND16(data);

    updateCyclesByOpcodemX(0x21);
    updatePCByOpcodemX(0x21);    
}

void and21Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    AND8(data);

    updateCyclesByOpcodeMx(0x21);
    updatePCByOpcodeMx(0x21);    
}

void and21mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX16());
    AND16(data);

    updateCyclesByOpcodemx(0x21);
    updatePCByOpcodemx(0x21);
}

/* 0x31 */
void and31MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectY8());
    AND8(data);

    updateCyclesByOpcodeMX(0x31);
    updatePCByOpcodeMX(0x31); 
}

void and31mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectY8());
    AND16(data);

    updateCyclesByOpcodemX(0x31);
    updatePCByOpcodemX(0x31); 
}

void and31Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectY16());
    AND8(data);

    updateCyclesByOpcodeMx(0x31);
    updatePCByOpcodeMx(0x31);     
} 

void and31mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectY16());
    AND16(data);

    updateCyclesByOpcodemx(0x31);
    updatePCByOpcodemx(0x31); 
}

/* 0x37 */
void and37MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY8());
    AND8(data);

    updateCyclesByOpcodeMX(0x37);
    updatePCByOpcodeMX(0x37); 
}

void and37mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY8());
    AND16(data);

    updateCyclesByOpcodemX(0x37);
    updatePCByOpcodemX(0x37);    
} 

void and37Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY16());
    AND8(data);

    updateCyclesByOpcodeMx(0x37);
    updatePCByOpcodeMx(0x37);     
}

void and37mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY8());
    AND8(data);

    updateCyclesByOpcodemx(0x37);
    updatePCByOpcodemx(0x37); 
}

/* 0x23 */
void and23M() {
    u8 data = memRead8NoTrap(amStackRelative());
    AND8(data);

    updateCyclesByOpcodeMX(0x23);
    updatePCByOpcodeMX(0x23);       
}

void and23m() {
    u16 data = memRead16NoTrap(amStackRelative());
    AND16(data);

    updateCyclesByOpcodemx(0x23);
    updatePCByOpcodemx(0x23);      
}

/* 0x33 */
void and33MX() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY8());
    AND8(data);

    updateCyclesByOpcodeMX(0x33);
    updatePCByOpcodeMX(0x33);
}

void and33mX() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY8());
    AND16(data);

    updateCyclesByOpcodemX(0x33);
    updatePCByOpcodemX(0x33); 
}

void and33Mx() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY16());
    AND8(data);

    updateCyclesByOpcodeMx(0x33);
    updatePCByOpcodeMx(0x33);
}

void and33mx() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY16());
    AND16(data);

    updateCyclesByOpcodemx(0x33);
    updatePCByOpcodemx(0x33);
}

/* ASL - Shift memory or accumulator left */
/* 0x0A */
void asl0AM() {
    ASL8(&CPU.A.al);

    updateCyclesByOpcodeMX(0x0A);
    updatePCByOpcodeMX(0x0A);
}

void asl0Am() {
    ASL16(&CPU.A.ac);

    updateCyclesByOpcodemx(0x0A);
    updatePCByOpcodemx(0x0A);
}

/* 0x0E */
void asl0EM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    ASL8(data);

    updateCyclesByOpcodeMX(0x0E);
    updatePCByOpcodeMX(0x0E);
}

void asl0Em() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    ASL16(data);

    updateCyclesByOpcodemx(0x0E);
    updatePCByOpcodemx(0x0E);
}

/* 0x06 */
void asl06M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    ASL8(data);

    updateCyclesByOpcodeMX(0x06);
    updatePCByOpcodeMX(0x06);
}

void asl06m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    ASL16(data);

    updateCyclesByOpcodemx(0x06);
    updatePCByOpcodemx(0x06);
}

/* 0x1E */
void asl1EMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    ASL8(data);

    updateCyclesByOpcodeMX(0x1E);
    updatePCByOpcodeMX(0x1E);   
}

void asl1EmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    ASL16(data);

    updateCyclesByOpcodemX(0x1E);
    updatePCByOpcodemX(0x1E);     
}

void asl1EMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    ASL8(data);

    updateCyclesByOpcodeMx(0x1E);
    updatePCByOpcodeMx(0x1E);     
}

void asl1Emx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    ASL16(data);

    updateCyclesByOpcodemx(0x1E);
    updatePCByOpcodemx(0x1E); 
}

/* 0x16 */
void asl16MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX8()));
    ASL8(data);

    updateCyclesByOpcodeMX(0x16);
    updatePCByOpcodeMX(0x16);
}

void asl16mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX8()));
    ASL16(data);

    updateCyclesByOpcodemX(0x16);
    updatePCByOpcodemX(0x16);
}

void asl16Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX16()));
    ASL8(data);

    updateCyclesByOpcodeMx(0x16);
    updatePCByOpcodeMx(0x16);
}

void asl16mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    ASL16(data);

    updateCyclesByOpcodemx(0x16);
    updatePCByOpcodemx(0x16);
}

/* BCC - Branch if carry clear */
/* 0x90 */
void bcc90() {
    BCC();

    updateCyclesByOpcodeMX(0x90);
    updatePCByOpcodeMX(0x90);
}

/* BCS - Branch if carry set */
/* 0xB0 */
void bcsB0() {
    BCS();

    updateCyclesByOpcodeMX(0xB0);
    updatePCByOpcodeMX(0xB0);
}

/* BEQ - Branch if equal */
/* 0xF0 */
void beqF0() {
    BEQ();

    updateCyclesByOpcodeMX(0xF0);
    updatePCByOpcodeMX(0xF0);
}

/* BIT - Test memory bits against accumulator */
/* 0x89 */
void bit89M() {
    u8 data = memRead8NoTrap(amImmediate());
    BIT8(data);

    updateCyclesByOpcodeMX(0x89);
    updatePCByOpcodeMX(0x89);
}

void bit89m() {
    u16 data = memRead16NoTrap(amImmediate());
    BIT8(data);

    updateCyclesByOpcodemx(0x89);
    updatePCByOpcodemx(0x89);
}

/* 0x2C */
void bit2CM() {
    u8 data = memRead8NoTrap(amAbsolute());
    BIT8(data);

    updateCyclesByOpcodeMX(0x2C);
    updatePCByOpcodeMX(0x2C);
}

void bit2Cm() {
    u16 data = memRead16NoTrap(amAbsolute());
    BIT16(data);

    updateCyclesByOpcodemx(0x2C);
    updatePCByOpcodemx(0x2C); 
}

/* 0x24 */
void bit24M() {
    u8 data = memRead8NoTrap(amDirectPage());
    BIT8(data);

    updateCyclesByOpcodeMX(0x24);
    updatePCByOpcodeMX(0x24);
}

void bit24m() {
    u16 data = memRead16NoTrap(amDirectPage());
    BIT16(data);

    updateCyclesByOpcodemx(0x24);
    updatePCByOpcodemx(0x24);    
}

/* 0x3C */
void bit3CMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    BIT8(data);

    updateCyclesByOpcodeMX(0x3C);
    updatePCByOpcodeMX(0x3C);
}

void bit3CmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    BIT16(data);

    updateCyclesByOpcodemX(0x3C);
    updatePCByOpcodemX(0x3C);
} 

void bit3CMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    BIT8(data);

    updateCyclesByOpcodeMx(0x3C);
    updatePCByOpcodeMx(0x3C);
}

void bit3Cmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    BIT16(data);

    updateCyclesByOpcodemx(0x3C);
    updatePCByOpcodemx(0x3C);
}

/* 0x34 */
void bit34MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    BIT8(data);

    updateCyclesByOpcodeMX(0x34);
    updatePCByOpcodeMX(0x34);
}

void bit34mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexX8());
    BIT16(data);

    updateCyclesByOpcodemX(0x34);
    updatePCByOpcodemX(0x34);
} 

void bit34Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexX16());
    BIT8(data);

    updateCyclesByOpcodeMx(0x34);
    updatePCByOpcodeMx(0x34);    
}

void bit34mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexX16());
    BIT16(data);

    updateCyclesByOpcodemx(0x34);
    updatePCByOpcodemx(0x34);
}

/* BMI - Branch if minus */
/* 0x30 */
void bmi30() {
    BMI();

    updateCyclesByOpcodeMX(0x30);
    updatePCByOpcodeMX(0x30);
}

/* BNE - Branch if not equal */
/* 0xD0 */
void bneD0() {
    BNE();

    updateCyclesByOpcodeMX(0xD0);
    updatePCByOpcodeMX(0xD0);
}

/* BPL - Branch if plus */
/* 0x10 */
void bpl10() {
    BPL();

    updateCyclesByOpcodeMX(0x10);
    updatePCByOpcodeMX(0x10);
}

/* BRA - Branch always */
/* 0x80 */
void bra80() {
    BRA();

    updateCyclesByOpcodeMX(0x80);
    updatePCByOpcodeMX(0x80);
}

/* BRK - Software break */
/* 0x00 */
void brk00() {
    BRK();

    updateCyclesByOpcodeMX(0x00);
    updatePCByOpcodeMX(0x00);
}

/* BRL - Branch always long */
/* 0x82 */
void brl82() {
    BRL();

    updateCyclesByOpcodeMX(0x82);
    updatePCByOpcodeMX(0x82);
}

/* BVC - Branch if overflow clear */
/* 0x50 */
void bvc50() {
    BVC();

    updateCyclesByOpcodeMX(0x50);
    updatePCByOpcodeMX(0x50);
}

/* BVS - Branch if overflow set */
/* 0x70 */
void bvs70() {
    BVS();

    updateCyclesByOpcodeMX(0x70);
    updatePCByOpcodeMX(0x70);
}

/* CLC - Clear carry flag */
/* 0x18 */
void clc18() {
    CLC();

    updateCyclesByOpcodeMX(0x18);
    updatePCByOpcodeMX(0x18);
}

/* CLD - Clear decimal mode flag */
/* 0xD8 */
void cldD8() {
    CLD();

    updateCyclesByOpcodeMX(0xD8);
    updatePCByOpcodeMX(0xD8);
}

/* CLI - Clear interrupt disable flag */
/* 0x58 */
void cli58() {
    CLI();

    updateCyclesByOpcodeMX(0x58);
    updatePCByOpcodeMX(0x58);
}

/* CLV - Clear overflow flag */
/* 0xB8 */
void clvB8() {
    CLV();

    updateCyclesByOpcodeMX(0xB8);
    updatePCByOpcodeMX(0xB8);
}

/* CMP - Compare accumulator with memory */
/* 0xC9 */
void cmpC9M() {
    u8 data = memRead8NoTrap(amImmediate());
    CMP8(data);

    updateCyclesByOpcodeMX(0xC9);
    updatePCByOpcodeMX(0xC9);
}

void cmpC9m() {
    u16 data = memRead16NoTrap(amImmediate());
    CMP16(data);

    updateCyclesByOpcodemx(0xB8);
    updatePCByOpcodemx(0xB8);
}

/* 0xCD */
void cmpCDM() {
    u8 data = memRead8NoTrap(amAbsolute());
    CMP8(data);

    updateCyclesByOpcodeMX(0xCD);
    updatePCByOpcodeMX(0xCD);
}

void cmpCDm() {
    u16 data = memRead16NoTrap(amAbsolute());
    CMP16(data);

    updateCyclesByOpcodemx(0xCD);
    updatePCByOpcodemx(0xCD);
}

/* 0xCF */
void cmpCFM() {
    u8 data = memRead8NoTrap(amAbsoluteLong());
    CMP8(data);

    updateCyclesByOpcodeMX(0xCF);
    updatePCByOpcodeMX(0xCF);
}

void cmpCFm() {
    u16 data = memRead16NoTrap(amAbsoluteLong());
    CMP16(data);

    updateCyclesByOpcodemx(0xCF);
    updatePCByOpcodemx(0xCF);
}

/* 0xC5 */
void cmpC5M() {
    u8 data = memRead8NoTrap(amDirectPage());
    CMP8(data);

    updateCyclesByOpcodeMX(0xC5);
    updatePCByOpcodeMX(0xC5);
}

void cmpC5m() {
    u16 data = memRead16NoTrap(amDirectPage());
    CMP16(data);

    updateCyclesByOpcodemx(0xC5);
    updatePCByOpcodemx(0xC5);
}

/* 0xD2 */
void cmpD2M() {
    u8 data = memRead8NoTrap(amDirectPageIndirect());
    CMP8(data);

    updateCyclesByOpcodeMX(0xD2);
    updatePCByOpcodeMX(0xD2);
}

void cmpD2m() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    CMP16(data);

    updateCyclesByOpcodemx(0xD2);
    updatePCByOpcodemx(0xD2);
}

/* 0xC7 */
void cmpC7M() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    CMP8(data);

    updateCyclesByOpcodeMX(0xC7);
    updatePCByOpcodeMX(0xC7);
}

void cmpC7m() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    CMP16(data);

    updateCyclesByOpcodeMX(0xC7);
    updatePCByOpcodeMX(0xC7);
}

/* 0xDD */
void cmpDDMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xDD);
    updatePCByOpcodeMX(0xDD);
}

void cmpDDmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    CMP16(data);

    updateCyclesByOpcodemX(0xDD);
    updatePCByOpcodemX(0xDD);    
}

void cmpDDMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    CMP8(data);

    updateCyclesByOpcodeMx(0xDD);
    updatePCByOpcodeMx(0xDD);    
}

void cmpDDmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    CMP16(data);

    updateCyclesByOpcodemx(0xDD);
    updatePCByOpcodemx(0xDD);
}

/* 0xDF */
void cmpDFMX() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xDF);
    updatePCByOpcodeMX(0xDF);
}

void cmpDFmX() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX8());
    CMP16(data);

    updateCyclesByOpcodemX(0xDF);
    updatePCByOpcodemX(0xDF);    
}

void cmpDFMx() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX16());
    CMP8(data);

    updateCyclesByOpcodeMx(0xDF);
    updatePCByOpcodeMx(0xDF);    
}

void cmpDFmx() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX16());
    CMP16(data);

    updateCyclesByOpcodemx(0xDF);
    updatePCByOpcodemx(0xDF);
}

/* 0xD9 */
void cmpD9MX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xD9);
    updatePCByOpcodeMX(0xD9);      
}

void cmpD9mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    CMP16(data);

    updateCyclesByOpcodemX(0xD9);
    updatePCByOpcodemX(0xD9);
}

void cmpD9Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    CMP8(data);

    updateCyclesByOpcodeMx(0xD9);
    updatePCByOpcodeMx(0xD9);
}

void cmpD9mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    CMP16(data);

    updateCyclesByOpcodemx(0xD9);
    updatePCByOpcodemx(0xD9);
}

/* 0xD5 */
void cmpD5MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xD5);
    updatePCByOpcodeMX(0xD5);    
}

void cmpD5mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexX8());
    CMP16(data);

    updateCyclesByOpcodemX(0xD5);
    updatePCByOpcodemX(0xD5);     
}

void cmpD5Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexX16());
    CMP8(data);

    updateCyclesByOpcodeMx(0xD5);
    updatePCByOpcodeMx(0xD5);     
}

void cmpD5mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexX16());
    CMP16(data);

    updateCyclesByOpcodemx(0xD5);
    updatePCByOpcodemx(0xD5); 
}

/* 0xC1 */
void cmpC1MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xC1);
    updatePCByOpcodeMX(0xC1);     
}

void cmpC1mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    CMP16(data);

    updateCyclesByOpcodemX(0xC1);
    updatePCByOpcodemX(0xC1);     
}

void cmpC1Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    CMP8(data);

    updateCyclesByOpcodeMx(0xC1);
    updatePCByOpcodeMx(0xC1);     
}

void cmpC1mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    CMP16(data);

    updateCyclesByOpcodemx(0xC1);
    updatePCByOpcodemx(0xC1); 
}

/* 0xD1 */
void cmpD1MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xD1);
    updatePCByOpcodeMX(0xD1);         
}

void cmpD1mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY8());
    CMP16(data);

    updateCyclesByOpcodemX(0xD1);
    updatePCByOpcodemX(0xD1);      
}

void cmpD1Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY16());
    CMP8(data);

    updateCyclesByOpcodeMx(0xD1);
    updatePCByOpcodeMx(0xD1);     
}

void cmpD1mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY16());
    CMP16(data);

    updateCyclesByOpcodemx(0xD1);
    updatePCByOpcodemx(0xD1); 
}

/* 0xD7 */
void cmpD7MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xD7);
    updatePCByOpcodeMX(0xD7); 
}

void cmpD7mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY8());
    CMP16(data);

    updateCyclesByOpcodemX(0xD7);
    updatePCByOpcodemX(0xD7);     
}

void cmpD7Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY16());
    CMP8(data);

    updateCyclesByOpcodeMx(0xD7);
    updatePCByOpcodeMx(0xD7);     
}

void cmpD7mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY16());
    CMP16(data);

    updateCyclesByOpcodemx(0xD7);
    updatePCByOpcodemx(0xD7); 
}

/* 0xC3 */
void cmpC3M() {
    u8* data = (u8*)(GETADDRESS(amStackRelative()));
    CMP8(data);

    updateCyclesByOpcodeMX(0xC3);
    updatePCByOpcodeMX(0xDC3);     
}

void cmpC3m() {
    u16* data = (u16*)(GETADDRESS(amStackRelative()));
    CMP16(data);

    updateCyclesByOpcodemx(0xC3);
    updatePCByOpcodemx(0xDC3); 
}

/* 0xD3 */
void cmpD3MX() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY8());
    CMP8(data);

    updateCyclesByOpcodeMX(0xD3);
    updatePCByOpcodeMX(0xD3);     
}

void cmpD3mX() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY8());
    CMP16(data);

    updateCyclesByOpcodemX(0xD3);
    updatePCByOpcodemX(0xD3);      
}

void cmpD3Mx() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY16());
    CMP8(data);

    updateCyclesByOpcodeMX(0xD3);
    updatePCByOpcodeMX(0xD3);      
}

void cmpD3mx() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY16());
    CMP16(data);

    updateCyclesByOpcodemx(0xD3);
    updatePCByOpcodemx(0xD3);  
}

/* COP - Coprocessor enable */
/* 0x02 */
void cop02() {
    COP();

    updateCyclesByOpcodeMX(0x02);
    updatePCByOpcodeMX(0x02);
}

/* CPX - Compare index register X with memory */
/* 0xE0 */
void cpxE0X() {
    u8 data = memRead8NoTrap(amImmediate());
    CPX8(data);

    updateCyclesByOpcodeMX(0xE0);
    updatePCByOpcodeMX(0xE0);
}

void cpxE0x() {
    u16 data = memRead16NoTrap(amImmediate());
    CPX16(data);

    updateCyclesByOpcodemx(0xE0);
    updatePCByOpcodemx(0xE0);
}

/* 0xEC */
void cpxECX() {
    u8 data = memRead8NoTrap(amAbsolute());
    CPX8(data);

    updateCyclesByOpcodeMX(0xEC);
    updatePCByOpcodeMX(0xEC);    
}

void cpxECx() {
    u16 data = memRead16NoTrap(amAbsolute());
    CPX16(data);

    updateCyclesByOpcodemx(0xEC);
    updatePCByOpcodemx(0xEC);
}

/* 0xE4 */
void cpxE4X() {
    u8 data = memRead8NoTrap(amDirectPage());
    CPX8(data);

    updateCyclesByOpcodeMX(0xE4);
    updatePCByOpcodeMX(0xE4);        
}

void cpxE4x() {
    u16 data = memRead16NoTrap(amDirectPage());
    CPX16(data);

    updateCyclesByOpcodemx(0xE4);
    updatePCByOpcodemx(0xE4); 
}

/* CPY - Compare index register Y with memory */
/* 0xC0 */
void cpyC0X() {
    u8 data = memRead8NoTrap(amImmediate());
    CPY8(data);

    updateCyclesByOpcodeMX(0xC0);
    updatePCByOpcodeMX(0xC0);    
}

void cpyC0x() {
    u16 data = memRead16NoTrap(amImmediate());
    CPY16(data);

    updateCyclesByOpcodemx(0xC0);
    updatePCByOpcodemx(0xC0);
}

/* 0xCC */
void cpyCCX() {
    u8 data = memRead8NoTrap(amAbsolute());
    CPY8(data);

    updateCyclesByOpcodeMX(0xCC);
    updatePCByOpcodeMX(0xCC);    
}

void cpyCCx() {
    u16 data = memRead16NoTrap(amAbsolute());
    CPY16(data);

    updateCyclesByOpcodemx(0xCC);
    updatePCByOpcodemx(0xCC);
}

/* 0xC4 */
void cpyC4X() {
    u8 data = memRead8NoTrap(amDirectPage());
    CPY8(data);

    updateCyclesByOpcodeMX(0xC4);
    updatePCByOpcodeMX(0xC4);    
}

void cpyC4x() {
    u16 data = memRead16NoTrap(amDirectPage());
    CPY16(data);

    updateCyclesByOpcodemx(0xC4);
    updatePCByOpcodemx(0xC4); 
}

/* DEC - Decrement */
/* 0x3A */
void dec3AM() {
    DEC8(&(CPU.A.al)); 

    updateCyclesByOpcodeMX(0x3A);
    updatePCByOpcodeMX(0x3A);
}

void dec3Am() {
    DEC8((u8*)(&CPU.A.ac));

    updateCyclesByOpcodemx(0x3A);
    updatePCByOpcodemx(0x3A);
}

/* 0xCE */
void decCEM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    DEC8(data);

    updateCyclesByOpcodeMX(0xCE);
    updatePCByOpcodeMX(0xCE); 
}

void decCEm() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    DEC16(data);

    updateCyclesByOpcodemx(0xCE);
    updatePCByOpcodemx(0xCE); 
}

/* 0xC6 */
void decC6M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    DEC8(data);

    updateCyclesByOpcodeMX(0xC6);
    updatePCByOpcodeMX(0xC6); 
}

void decC6m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    DEC16(data);

    updateCyclesByOpcodemx(0xC6);
    updatePCByOpcodemx(0xC6); 
}

/* 0xDE */
void decDEMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    DEC8(data);

    updateCyclesByOpcodeMX(0xDE);
    updatePCByOpcodeMX(0xDE); 
}

void decDEmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    DEC16(data);

    updateCyclesByOpcodemX(0xDE);
    updatePCByOpcodemX(0xDE);     
}

void decDEMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    DEC8(data);

    updateCyclesByOpcodeMx(0xDE);
    updatePCByOpcodeMx(0xDE);     
}

void decDEmx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    DEC16(data);

    updateCyclesByOpcodemx(0xDE);
    updatePCByOpcodemx(0xDE); 
}

/* 0xD6 */
void decD6MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX8()));
    DEC8(data);

    updateCyclesByOpcodeMX(0xD6);
    updatePCByOpcodeMX(0xD6);
}

void decD6mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX8()));
    DEC16(data);

    updateCyclesByOpcodemX(0xD6);
    updatePCByOpcodemX(0xD6);    
}

void decD6Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX16()));
    DEC8(data);

    updateCyclesByOpcodeMx(0xD6);
    updatePCByOpcodeMx(0xD6);    
}

void decD6mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    DEC16(data);

    updateCyclesByOpcodemx(0xD6);
    updatePCByOpcodemx(0xD6);
}

/* DEX - Decrement index register X */
/* 0xCA */
void dexCAX() {
    DEX8();

    updateCyclesByOpcodeMX(0xCA);
    updatePCByOpcodeMX(0xCA);
}

void dexCAx() {
    DEX16();

    updateCyclesByOpcodemx(0xCA);
    updatePCByOpcodemx(0xCA);
}

/* DEY - Decrement index register Y */
/* 0x88 */
void dey88X() {
    DEY8();

    updateCyclesByOpcodeMX(0x88);
    updatePCByOpcodeMX(0x88);
}

void dey88x() {
    DEY16();

    updateCyclesByOpcodemx(0x88);
    updatePCByOpcodemx(0x88);
}

/* EOR - Exclusive or accumulator with memory */
/* 0x49 */
void eor49M() {
    u8 data = memRead8NoTrap(amImmediate());
    EOR8(data);

    updateCyclesByOpcodeMX(0x49);
    updatePCByOpcodeMX(0x49);
}

void eor49m() {
    u16 data = memRead16NoTrap(amImmediate());
    EOR16(data);

    updateCyclesByOpcodemx(0x49);
    updatePCByOpcodemx(0x49);
}

/* 0x4D */
void eor4DM() {
    u8 data = memRead8NoTrap(amAbsolute());
    EOR8(data);

    updateCyclesByOpcodeMX(0x4D);
    updatePCByOpcodeMX(0x4D);       
}

void eor4Dm() {
    u16 data = memRead16NoTrap(amAbsolute());
    EOR16(data);

    updateCyclesByOpcodemx(0x4D);
    updatePCByOpcodemx(0x4D);
}

/* 0x4F */
void eor4FM() {
    u8 data = memRead8NoTrap(amAbsoluteLong());
    EOR8(data);

    updateCyclesByOpcodeMX(0x4F);
    updatePCByOpcodeMX(0x4F);
}

void eor4Fm() {
    u16 data = memRead16NoTrap(amAbsoluteLong());
    EOR16(data);

    updateCyclesByOpcodemx(0x4F);
    updatePCByOpcodemx(0x4F);
}

/* 0x45 */
void eor45M() {
    u8 data = memRead8NoTrap(amDirectPage());
    EOR8(data);

    updateCyclesByOpcodeMX(0x45);
    updatePCByOpcodeMX(0x45);
}

void eor45m() {
    u16 data = memRead16NoTrap(amDirectPage());
    EOR16(data);

    updateCyclesByOpcodemx(0x45);
    updatePCByOpcodemx(0x45);
}

/* 0x52 */
void eor52M() {
    u8 data = memRead8NoTrap(amDirectPageIndirect());
    EOR8(data);

    updateCyclesByOpcodeMX(0x52);
    updatePCByOpcodeMX(0x52);
}

void eor52m() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    EOR16(data);

    updateCyclesByOpcodemx(0x52);
    updatePCByOpcodemx(0x52);
}

/* 0x47 */
void eor47M() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    EOR8(data);

    updateCyclesByOpcodeMX(0x47);
    updatePCByOpcodeMX(0x47);
}

void eor47m() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    EOR16(data);

    updateCyclesByOpcodemx(0x47);
    updatePCByOpcodemx(0x47);
}

/* 0x5D */
void eor5DMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x5D);
    updatePCByOpcodeMX(0x5D);
}

void eor5DmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    EOR16(data);

    updateCyclesByOpcodemX(0x5D);
    updatePCByOpcodemX(0x5D);    
}

void eor5DMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x5D);
    updatePCByOpcodeMx(0x5D);    
}

void eor5Dmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    EOR16(data);

    updateCyclesByOpcodemx(0x5D);
    updatePCByOpcodemx(0x5D);
}

/* 0x5F */
void eor5FMX() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x5F);
    updatePCByOpcodeMX(0x5F);
}

void eor5FmX() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX8());
    EOR16(data);

    updateCyclesByOpcodemX(0x5F);
    updatePCByOpcodemX(0x5F);    
}

void eor5FMx() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x5F);
    updatePCByOpcodeMx(0x5F);    
}

void eor5Fmx() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX16());
    EOR16(data);

    updateCyclesByOpcodemx(0x5F);
    updatePCByOpcodemx(0x5F);
}

/* 0x59 */
void eor59MX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x59);
    updatePCByOpcodeMX(0x59);
}

void eor59mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    EOR16(data);

    updateCyclesByOpcodemX(0x59);
    updatePCByOpcodemX(0x59);    
}

void eor59Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x59);
    updatePCByOpcodeMx(0x59);    
}

void eor59mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    EOR16(data);

    updateCyclesByOpcodemx(0x59);
    updatePCByOpcodemx(0x59);
}

/* 0x55 */
void eor55MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x55);
    updatePCByOpcodeMX(0x55);    
}

void eor55mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexX8());
    EOR16(data);

    updateCyclesByOpcodemX(0x55);
    updatePCByOpcodemX(0x55);     
}

void eor55Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexX16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x55);
    updatePCByOpcodeMx(0x55);     
}

void eor55mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexX16());
    EOR16(data);

    updateCyclesByOpcodemx(0x55);
    updatePCByOpcodemx(0x55); 
}

/* 0x41 */
void eor41MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x41);
    updatePCByOpcodeMX(0x41);
}

void eor41mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    EOR16(data);

    updateCyclesByOpcodemX(0x41);
    updatePCByOpcodemX(0x41);    
}

void eor41Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x41);
    updatePCByOpcodeMx(0x41);    
}

void eor41mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX16());
    EOR16(data);

    updateCyclesByOpcodemx(0x41);
    updatePCByOpcodemx(0x41);
}

/* 0x51 */
void eor51MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x51);
    updatePCByOpcodeMX(0x51);
}

void eor51mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY8());
    EOR16(data);

    updateCyclesByOpcodemX(0x51);
    updatePCByOpcodemX(0x51);   
}

void eor51Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x51);
    updatePCByOpcodeMx(0x51);    
}

void eor51mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY16());
    EOR16(data);

    updateCyclesByOpcodemx(0x51);
    updatePCByOpcodemx(0x51);
}

/* 0x57 */
void eor57MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x57);
    updatePCByOpcodeMX(0x57);
}

void eor57mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY8());
    EOR16(data);

    updateCyclesByOpcodemX(0x57);
    updatePCByOpcodemX(0x57);    
}

void eor57Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x57);
    updatePCByOpcodeMx(0x57);    
}

void eor57mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY16());
    EOR16(data);

    updateCyclesByOpcodemx(0x57);
    updatePCByOpcodemx(0x57);
}

/* 0x43 */
void eor43M() {
    u8 data = memRead8NoTrap(amStackRelative());
    EOR8(data);

    updateCyclesByOpcodeMX(0x43);
    updatePCByOpcodeMX(0x43);
}

void eor43m() {
    u16 data = memRead16NoTrap(amStackRelative());
    EOR16(data);

    updateCyclesByOpcodemx(0x43);
    updatePCByOpcodemx(0x43);
}

/* 0x53 */
void eor53MX() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY8());
    EOR8(data);

    updateCyclesByOpcodeMX(0x53);
    updatePCByOpcodeMX(0x53);
}

void eor53mX() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY8());
    EOR16(data);

    updateCyclesByOpcodemX(0x53);
    updatePCByOpcodemX(0x53);    
}

void eor53Mx() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY16());
    EOR8(data);

    updateCyclesByOpcodeMx(0x53);
    updatePCByOpcodeMx(0x53);    
}

void eor53mx() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY16());
    EOR16(data);

    updateCyclesByOpcodemx(0x53);
    updatePCByOpcodemx(0x53);
}

/* INC - Increment */
/* 0x1A */
void inc1AM() {
    INC8(&CPU.A.al);

    updateCyclesByOpcodeMX(0x1A);
    updatePCByOpcodeMX(0x1A);
}

void inc1Am() {
    INC16(&CPU.A.ac);

    updateCyclesByOpcodemx(0x1A);
    updatePCByOpcodemx(0x1A);
}

/* 0xEE */
void incEEM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    INC8(data);

    updateCyclesByOpcodeMX(0xEE);
    updatePCByOpcodeMX(0xEE);
}

void incEEm() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    INC16(data);

    updateCyclesByOpcodemx(0xEE);
    updatePCByOpcodemx(0xEE);
}

/* 0xE6 */
void incE6M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    INC8(data);

    updateCyclesByOpcodeMX(0xE6);
    updatePCByOpcodeMX(0xE6);
}

void incE6m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    INC16(data);

    updateCyclesByOpcodemx(0xE6);
    updatePCByOpcodemx(0xE6);
}

/* 0xFE */
void incFEMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    INC8(data);

    updateCyclesByOpcodeMX(0xFE);
    updatePCByOpcodeMX(0xFE);
}

void incFEmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    INC16(data);

    updateCyclesByOpcodemX(0xFE);
    updatePCByOpcodemX(0xFE);
}

void incFEMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    INC8(data);

    updateCyclesByOpcodeMx(0xFE);
    updatePCByOpcodeMx(0xFE);
}

void incFEmx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    INC16(data);

    updateCyclesByOpcodemx(0xFE);
    updatePCByOpcodemx(0xFE);}

/* 0xF6 */
void incF6MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX8()));
    INC8(data);

    updateCyclesByOpcodeMX(0xF6);
    updatePCByOpcodeMX(0xF6);
}

void incF6mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX8()));
    INC16(data);

    updateCyclesByOpcodemX(0xF6);
    updatePCByOpcodemX(0xF6);    
}

void incF6Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX16()));
    INC8(data);

    updateCyclesByOpcodeMx(0xF6);
    updatePCByOpcodeMx(0xF6);    
}

void incF6mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    INC16(data);

    updateCyclesByOpcodemx(0xF6);
    updatePCByOpcodemx(0xF6);
}

/* INX - Increment index register X */
/* 0xE8 */
void inxE8X() {
    INX8();

    updateCyclesByOpcodeMX(0xE8);
    updatePCByOpcodeMX(0xE8);
}

void inxE8x() {
    INX16();

    updateCyclesByOpcodemx(0xE8);
    updatePCByOpcodemx(0xE8);
}

/* INY - Increment index register Y */
/* 0xC8 */
void inyC8X() {
    INY8();

    updateCyclesByOpcodeMX(0xC8);
    updatePCByOpcodeMX(0xC8);    
}

void inyC8x() {
    INY16();

    updateCyclesByOpcodemx(0xC8);
    updatePCByOpcodemx(0xC8);
}

/* JMP - Jump */
/* 0x4C */
void jmp4C() {
    u16 data = memRead16NoTrap(amAbsolute());
    JMP(data);

    updateCyclesByOpcodemx(0x4C);
    updatePCByOpcodemx(0x4C);
}

/* 0x6C */
void jmp6C() {
    u16 data = memRead16NoTrap(amAbsoluteIndirect());
    JMP(data);

    updateCyclesByOpcodemx(0x6C);
    updatePCByOpcodemx(0x6C);
}

/* 0x7C */
void jmp7CX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexIndirect8());
    JMP(data);

    updateCyclesByOpcodemX(0x7C);
    updatePCByOpcodemX(0x7C);
}

void jmp7Cx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexIndirect16());
    JMP(data);

    updateCyclesByOpcodemx(0x7C);
    updatePCByOpcodemx(0x7C);
}

/* 0x5C */
void jmp5C() {
    u32 data = *((u32*)GETADDRESS(amAbsoluteLong()));
    JML(data);

    updateCyclesByOpcodemx(0x5C);
    updatePCByOpcodemx(0x5C);
}

/* 0xDC */
void jmpDC() {
    u32 data = *((u32*)GETADDRESS(amAbsoluteIndirectLong()));
    JML(data);

    updateCyclesByOpcodemx(0xDC);
    updatePCByOpcodemx(0xDC);
}

/* JSR - Jump to subroutine */
/* 0x20 */
void jsr20() {
    u16 data = memRead16NoTrap(amAbsolute());
    JSR(data);

    updateCyclesByOpcodemx(0x20);
    updatePCByOpcodemx(0x20);
}

/* 0xFC */
void jsrFCX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexIndirect8());
    JSR(data);

    updateCyclesByOpcodemX(0xFC);
    updatePCByOpcodemX(0xFC);
}

void jsrFCx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexIndirect16());
    JSR(data);

    updateCyclesByOpcodemx(0xFC);
    updatePCByOpcodemx(0xFC);
}

/* 0x22 */
void jsr22() {
    u32 data = *((u32*)GETADDRESS(amAbsoluteLong()));
    JSL(data);

    updateCyclesByOpcodemX(0x22);
    updatePCByOpcodemX(0x22);
}

/* LDA - Load accumulator from memory */
/* 0xA9 */
void ldaA9M() {
    u8 data = memRead8NoTrap(amImmediate());
    LDA8(data);

    updateCyclesByOpcodeMX(0xA9);
    updatePCByOpcodeMX(0xA9);
}

void ldaA9m() {
    u16 data = memRead16NoTrap(amImmediate());
    LDA16(data);

    updateCyclesByOpcodemx(0xA9);
    updatePCByOpcodemx(0xA9);
}

/* 0xAD */
void ldaADM() {
    u8 data = memRead8NoTrap(amAbsolute());
    LDA8(data);

    updateCyclesByOpcodeMX(0xAD);
    updatePCByOpcodeMX(0xAD);
}

void ldaADm() {
    u16 data = memRead16NoTrap(amAbsolute());
    LDA16(data);

    updateCyclesByOpcodemx(0xAD);
    updatePCByOpcodemx(0xAD);
}

/* 0xAF */
void ldaAFM() {
    u8 data = memRead8NoTrap(amAbsoluteLong());
    LDA8(data);

    updateCyclesByOpcodeMX(0xAF);
    updatePCByOpcodeMX(0xAF);
}

void ldaAFm() {
    u16 data = memRead16NoTrap(amAbsoluteLong());
    LDA16(data);

    updateCyclesByOpcodemx(0xAF);
    updatePCByOpcodemx(0xAF);
}

/* 0xA5 */
void ldaA5M() {
    u8 data = memRead8NoTrap(amDirectPage());
    LDA8(data);

    updateCyclesByOpcodeMX(0xA5);
    updatePCByOpcodeMX(0xA5);
}

void ldaA5m() {
    u16 data = memRead16NoTrap(amDirectPage());
    LDA16(data);

    updateCyclesByOpcodemx(0xA5);
    updatePCByOpcodemx(0xA5);
}

/* 0xB2 */
void ldaB2M() {
    u8 data = memRead8NoTrap(amDirectPageIndirect());
    LDA8(data);

    updateCyclesByOpcodeMX(0xB2);
    updatePCByOpcodeMX(0xB2);
}

void ldaB2m() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    LDA16(data);

    updateCyclesByOpcodemx(0xB2);
    updatePCByOpcodemx(0xB2);
}

/* 0xA7 */
void ldaA7M() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    LDA8(data);

    updateCyclesByOpcodeMX(0xA7);
    updatePCByOpcodeMX(0xA7);
}

void ldaA7m() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    LDA16(data);

    updateCyclesByOpcodemx(0xA7);
    updatePCByOpcodemx(0xA7);
}

/* 0xBD */
void ldaBDMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xBD);
    updatePCByOpcodeMX(0xBD);
}

void ldaBDmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    LDA16(data);

    updateCyclesByOpcodemX(0xBD);
    updatePCByOpcodemX(0xBD);    
}

void ldaBDMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xBD);
    updatePCByOpcodeMx(0xBD);    
}

void ldaBDmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    LDA16(data);

    updateCyclesByOpcodemx(0xBD);
    updatePCByOpcodemx(0xBD);
}

/* 0xBF */
void ldaBFMX() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xBF);
    updatePCByOpcodeMX(0xBF);
}

void ldaBFmX() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX8());
    LDA16(data);

    updateCyclesByOpcodemX(0xBF);
    updatePCByOpcodemX(0xBF);    
}

void ldaBFMx() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xBF);
    updatePCByOpcodeMx(0xBF);    
}

void ldaBFmx() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX16());
    LDA16(data);

    updateCyclesByOpcodemx(0xBF);
    updatePCByOpcodemx(0xBF);
}

/* 0xB9 */
void ldaB9MX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xB9);
    updatePCByOpcodeMX(0xB9);    
}

void ldaB9mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    LDA16(data);

    updateCyclesByOpcodemX(0xB9);
    updatePCByOpcodemX(0xB9);     
}

void ldaB9Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xB9);
    updatePCByOpcodeMx(0xB9);     
}

void ldaB9mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    LDA16(data);

    updateCyclesByOpcodemx(0xB9);
    updatePCByOpcodemx(0xB9); 
}

/* 0xB5 */
void ldaB5MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xB5);
    updatePCByOpcodeMX(0xB5);     
}

void ldaB5mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexX8());
    LDA16(data);

    updateCyclesByOpcodemX(0xB5);
    updatePCByOpcodemX(0xB5);      
}

void ldaB5Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexX16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xB5);
    updatePCByOpcodeMx(0xB5);      
}

void ldaB5mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexX16());
    LDA16(data);

    updateCyclesByOpcodemx(0xB5);
    updatePCByOpcodemx(0xB5);  
}

/* 0xA1 */
void ldaA1MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xA1);
    updatePCByOpcodeMX(0xA1);      
}

void ldaA1mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    LDA16(data);

    updateCyclesByOpcodemX(0xA1);
    updatePCByOpcodemX(0xA1);    
}

void ldaA1Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xA1);
    updatePCByOpcodeMx(0xA1);    
}

void ldaA1mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX16());
    LDA16(data);

    updateCyclesByOpcodemx(0xA1);
    updatePCByOpcodemx(0xA1);
}

/* 0xB1 */
void ldaB1MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xB1);
    updatePCByOpcodeMX(0xB1);    
}

void ldaB1mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    LDA16(data);

    updateCyclesByOpcodeMX(0xB1);
    updatePCByOpcodeMX(0xB1);    
}

void ldaB1Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xB1);
    updatePCByOpcodeMx(0xB1);    
}

void ldaB1mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX16());
    LDA16(data);

    updateCyclesByOpcodemx(0xB1);
    updatePCByOpcodemx(0xB1);
}

/* 0xB7 */
void ldaB7MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xB7);
    updatePCByOpcodeMX(0xB7);            
}

void ldaB7mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY8());
    LDA16(data);

    updateCyclesByOpcodemX(0xB7);
    updatePCByOpcodemX(0xB7);     
}

void ldaB7Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xB7);
    updatePCByOpcodeMx(0xB7);     
}

void ldaB7mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY16());
    LDA16(data);

    updateCyclesByOpcodemx(0xB7);
    updatePCByOpcodemx(0xB7); 
}

/* 0xA3 */
void ldaA3M() {
    u8 data = memRead8NoTrap(amStackRelative());
    LDA8(data);

    updateCyclesByOpcodeMX(0xA3);
    updatePCByOpcodeMX(0xA3);     
}

void ldaA3m() {
    u16 data = memRead16NoTrap(amStackRelative());
    LDA16(data);

    updateCyclesByOpcodemx(0xA3);
    updatePCByOpcodemx(0xA3); 
}

/* 0xB3 */
void ldaB3MX() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY8());
    LDA8(data);

    updateCyclesByOpcodeMX(0xB3);
    updatePCByOpcodeMX(0xB3);     
}

void ldaB3mX() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY8());
    LDA16(data);

    updateCyclesByOpcodemX(0xB3);
    updatePCByOpcodemX(0xB3);      
}

void ldaB3Mx() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY16());
    LDA8(data);

    updateCyclesByOpcodeMx(0xB3);
    updatePCByOpcodeMx(0xB3);      
}

void ldaB3mx() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY16());
    LDA16(data);

    updateCyclesByOpcodemx(0xB3);
    updatePCByOpcodemx(0xB3);  
}

/* LDX - Load index register X from memory */
/* 0xA2 */
void ldxA2X() {
    u8 data = memRead8NoTrap(amImmediate());
    LDX8(data);

    updateCyclesByOpcodeMX(0xA2);
    updatePCByOpcodeMX(0xA2);      
}

void ldxA2x() {
    u16 data = memRead16NoTrap(amImmediate());
    LDX16(data);

    updateCyclesByOpcodemx(0xA2);
    updatePCByOpcodemx(0xA2); 
}

/* 0xAE */
void ldxAEX() {
    u8 data = memRead8NoTrap(amAbsolute());
    LDX8(data);

    updateCyclesByOpcodeMX(0xAE);
    updatePCByOpcodeMX(0xAE);     
}

void ldxAEx() {
    u16 data = memRead16NoTrap(amAbsolute());
    LDX16(data);

    updateCyclesByOpcodemx(0xAE);
    updatePCByOpcodemx(0xAE); 
}

/* 0xA6 */
void ldxA6X() {
    u8 data = memRead8NoTrap(amDirectPage());
    LDX8(data);

    updateCyclesByOpcodeMX(0xA6);
    updatePCByOpcodeMX(0xA6);
}

void ldxA6x() {
    u16 data = memRead16NoTrap(amAbsolute());
    LDX16(data);

    updateCyclesByOpcodemx(0xAE);
    updatePCByOpcodemx(0xAE); 
}

/* 0xBE */
void ldxBEX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    LDX8(data);

    updateCyclesByOpcodeMX(0xBE);
    updatePCByOpcodeMX(0xBE);     
}

void ldxBEx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    LDX16(data);

    updateCyclesByOpcodeMX(0xBE);
    updatePCByOpcodeMX(0xBE); 
}

/* 0xB6 */
void ldxB6X() {
    u8 data = memRead8NoTrap(amDirectPageIndexY8());
    LDX8(data);

    updateCyclesByOpcodeMX(0xB6);
    updatePCByOpcodeMX(0xB6);    
}

void ldxB6x() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    LDX16(data);

    updateCyclesByOpcodemx(0xB6);
    updatePCByOpcodemx(0xB6);
}

/* LDY - Load index register Y from memory */
/* 0xA0 */
void ldyA0X() {
    u8 data = memRead8NoTrap(amImmediate());
    LDY8(data);

    updateCyclesByOpcodeMX(0xA0);
    updatePCByOpcodeMX(0xA0);    
}

void ldyA0x() {
    u16 data = memRead16NoTrap(amImmediate());
    LDY16(data);

    updateCyclesByOpcodemx(0xA0);
    updatePCByOpcodemx(0xA0);
}

/* 0xAC */
void ldyACX() {
    u8 data = memRead8NoTrap(amAbsolute());
    LDY8(data);

    updateCyclesByOpcodeMX(0xA0);
    updatePCByOpcodeMX(0xA0);
}

void ldyACx() {
    u16 data = memRead16NoTrap(amAbsolute());
    LDY16(data);

    updateCyclesByOpcodemx(0xA0);
    updatePCByOpcodemx(0xA0);
}

/* 0xA4 */
void ldyA4X() {
    u8 data = memRead8NoTrap(amDirectPage());
    LDY8(data);

    updateCyclesByOpcodeMX(0xA4);
    updatePCByOpcodeMX(0xA4);
}

void ldyA4x() {
    u16 data = memRead16NoTrap(amAbsolute());
    LDY16(data);

    updateCyclesByOpcodemx(0xA4);
    updatePCByOpcodemx(0xA4);
}

/* 0xBC */
void ldyBCX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    LDY8(data);

    updateCyclesByOpcodeMX(0xBC);
    updatePCByOpcodeMX(0xBC);    
}

void ldyBCx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    LDY16(data);

    updateCyclesByOpcodemx(0xBC);
    updatePCByOpcodemx(0xBC); 
}

/* 0xB4 */
void ldxB4X() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    LDY8(data);

    updateCyclesByOpcodeMX(0xB4);
    updatePCByOpcodeMX(0xB4);     
}

void ldxB4x() {
    u16 data = memRead16NoTrap(amDirectPageIndexX16());
    LDY16(data);

    updateCyclesByOpcodemx(0xB4);
    updatePCByOpcodemx(0xB4); 
}

/* LSR - Logical shift memory or accumulator right */
/* 0x4A */
void lsr4AM() {
    LSR8(&CPU.A.al);

    updateCyclesByOpcodeMX(0x4A);
    updatePCByOpcodeMX(0x4A);     
} 

void lsr4Am() {
    LSR16(&CPU.A.ac);

    updateCyclesByOpcodemx(0x4A);
    updatePCByOpcodemx(0x4A);
}

/* 0x4E */
void lsr4EM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    LSR8(data);

    updateCyclesByOpcodeMX(0x4E);
    updatePCByOpcodeMX(0x4E);
}

void lsr4Em() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    LSR16(data);

    updateCyclesByOpcodemx(0x4E);
    updatePCByOpcodemx(0x4E);
}

/* 0x46 */
void lsr46M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    LSR8(data);

    updateCyclesByOpcodeMX(0x46);
    updatePCByOpcodeMX(0x46);
}

void lsr46m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    LSR16(data);

    updateCyclesByOpcodemx(0x46);
    updatePCByOpcodemx(0x46);
}

/* 0x5E */
void lsr5EMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    LSR8(data);

    updateCyclesByOpcodeMX(0x5E);
    updatePCByOpcodeMX(0x5E);    
}

void lsr5EmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    LSR16(data);

    updateCyclesByOpcodemX(0x5E);
    updatePCByOpcodemX(0x5E);     
}

void lsr5EMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    LSR8(data);

    updateCyclesByOpcodeMx(0x5E);
    updatePCByOpcodeMx(0x5E);     
}

void lsr5Emx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    LSR16(data);

    updateCyclesByOpcodemx(0x5E);
    updatePCByOpcodemx(0x5E); 
}

/* 0x56 */
void lsr56MX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    LSR8(data);

    updateCyclesByOpcodeMX(0x56);
    updatePCByOpcodeMX(0x56);     
}

void lsr56mX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    LSR16(data);

    updateCyclesByOpcodemX(0x56);
    updatePCByOpcodemX(0x56);     
}

void lsr56Mx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    LSR8(data);

    updateCyclesByOpcodeMx(0x56);
    updatePCByOpcodeMx(0x56);     
}

void lsr56mx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    LSR16(data);

    updateCyclesByOpcodemx(0x56);
    updatePCByOpcodemx(0x56); 
}

/* MVN - Block move next */
/* 0x54 */
void mvn54() {
    /* TODO */
}

/* MVP - Block move previous */
/* 0x44 */
void mvp44() {
    /* TODO */
}

/* NOP - No operation */
/* 0xEA */
void nopEA() {
    NOP();
}

/* ORA - Or accumulator with memory */
/* 0x09 */
void ora09M() {
    u8 data = memRead8NoTrap(amImmediate());
    ORA8(data);

    updateCyclesByOpcodeMX(0x09);
    updatePCByOpcodeMX(0x09); 
}

void ora09m() {
    u16 data = memRead16NoTrap(amImmediate());
    ORA16(data);

    updateCyclesByOpcodemx(0x09);
    updatePCByOpcodemx(0x09); 
}

/* 0x0D */
void ora0DM() {
    u8 data = memRead8NoTrap(amAbsolute());
    ORA8(data);

    updateCyclesByOpcodeMX(0x0D);
    updatePCByOpcodeMX(0x0D);     
}

void ora0Dm() {
    u16 data = memRead16NoTrap(amAbsolute());
    ORA16(data);

    updateCyclesByOpcodemx(0x0D);
    updatePCByOpcodemx(0x0D);
}

/* 0x0F */
void ora0FM() {
    u8 data = memRead8NoTrap(amAbsoluteLong());
    ORA8(data);

    updateCyclesByOpcodeMX(0x0F);
    updatePCByOpcodeMX(0x0F);     
}

void ora0Fm() {
    u16 data = memRead16NoTrap(amAbsoluteLong());
    ORA16(data);

    updateCyclesByOpcodemx(0x0F);
    updatePCByOpcodemx(0x0F); 
}

/* 0x05 */
void ora05M() {
    u8 data = memRead8NoTrap(amDirectPage());
    ORA8(data);

    updateCyclesByOpcodeMX(0x05);
    updatePCByOpcodeMX(0x05);     
}

void ora05m() {
    u16 data = memRead16NoTrap(amDirectPage());
    ORA16(data);

    updateCyclesByOpcodemx(0x05);
    updatePCByOpcodemx(0x05); 
}

/* 0x12 */
void ora12M() {
    u8 data = memRead8NoTrap(amDirectPageIndirect());
    ORA8(data);

    updateCyclesByOpcodeMX(0x12);
    updatePCByOpcodeMX(0x12);     
}

void ora12m() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    ORA16(data);

    updateCyclesByOpcodemx(0x12);
    updatePCByOpcodemx(0x12); 
}

/* 0x07 */
void ora07M() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    ORA8(data);

    updateCyclesByOpcodeMX(0x07);
    updatePCByOpcodeMX(0x07);     
}

void ora07m() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    ORA16(data);

    updateCyclesByOpcodemx(0x07);
    updatePCByOpcodemx(0x07);  
}

/* 0x1D */
void ora1DMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x1D);
    updatePCByOpcodeMX(0x1D);      
}

void ora1DmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    ORA16(data);

    updateCyclesByOpcodemX(0x1D);
    updatePCByOpcodemX(0x1D);    
}

void ora1DMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x1D);
    updatePCByOpcodeMx(0x1D);     
}

void ora1Dmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    ORA16(data);

    updateCyclesByOpcodemx(0x1D);
    updatePCByOpcodemx(0x1D); 
}

/* 0x1F */
void ora1FMX() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x1F);
    updatePCByOpcodeMX(0x1F);     
}

void ora1FmX() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX8());
    ORA16(data);

    updateCyclesByOpcodemX(0x1F);
    updatePCByOpcodemX(0x1F);    
}

void ora1FMx() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x1F);
    updatePCByOpcodeMx(0x1F);      
}

void ora1Fmx() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX16());
    ORA16(data);

    updateCyclesByOpcodemx(0x1F);
    updatePCByOpcodemx(0x1F);  
}

/* 0x19 */
void ora19MX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x19);
    updatePCByOpcodeMX(0x19);      
}

void ora19mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    ORA16(data);

    updateCyclesByOpcodemX(0x19);
    updatePCByOpcodemX(0x19);   
}

void ora19Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x19);
    updatePCByOpcodeMx(0x19);    
}

void ora19mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    ORA16(data);

    updateCyclesByOpcodemx(0x19);
    updatePCByOpcodemx(0x19);
}

/* 0x15 */
void ora15MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexX8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x15);
    updatePCByOpcodeMX(0x15);    
}

void ora15mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    ORA16(data);

    updateCyclesByOpcodemX(0x15);
    updatePCByOpcodemX(0x15);    
}

void ora15Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x15);
    updatePCByOpcodeMx(0x15);      
}

void ora15mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    ORA16(data);

    updateCyclesByOpcodemx(0x15);
    updatePCByOpcodemx(0x15);  
}

/* 0x01 */
void ora01MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x01);
    updatePCByOpcodeMX(0x01);  
}

void ora01mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    ORA16(data);

    updateCyclesByOpcodemX(0x01);
    updatePCByOpcodemX(0x01); 
}

void ora01Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x01);
    updatePCByOpcodeMx(0x01);     
}

void ora01mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX16());
    ORA16(data);

    updateCyclesByOpcodemx(0x01);
    updatePCByOpcodemx(0x01); 
}

/* 0x11 */
void ora11MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x11);
    updatePCByOpcodeMX(0x11);     
}

void ora11mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    ORA16(data);

    updateCyclesByOpcodemX(0x11);
    updatePCByOpcodemX(0x11);     
}

void ora11Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x11);
    updatePCByOpcodeMx(0x11);     
}

void ora11mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX16());
    ORA16(data);

    updateCyclesByOpcodemx(0x11);
    updatePCByOpcodemx(0x11); 
}

/* 0x17 */
void ora17MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x17);
    updatePCByOpcodeMX(0x17);     
}

void ora17mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY8());
    ORA16(data);

    updateCyclesByOpcodemX(0x17);
    updatePCByOpcodemX(0x17);     
}

void ora17Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x17);
    updatePCByOpcodeMx(0x17);     
}

void ora17mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY16());
    ORA16(data);

    updateCyclesByOpcodemx(0x17);
    updatePCByOpcodemx(0x17); 
}

/* 0x03 */
void ora03M() {
    u8 data = memRead8NoTrap(amStackRelative());
    ORA8(data);

    updateCyclesByOpcodeMX(0x03);
    updatePCByOpcodeMX(0x03);     
}

void ora03m() {
    u16 data = memRead16NoTrap(amStackRelative());
    ORA16(data);

    updateCyclesByOpcodeMX(0x03);
    updatePCByOpcodeMX(0x03); 
}

/* 0x13 */
void ora13MX() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY8());
    ORA8(data);

    updateCyclesByOpcodeMX(0x13);
    updatePCByOpcodeMX(0x13); 
}

void ora13mX() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY8());
    ORA16(data);

    updateCyclesByOpcodemX(0x13);
    updatePCByOpcodemX(0x13); 
}

void ora13Mx() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY16());
    ORA8(data);

    updateCyclesByOpcodeMx(0x13);
    updatePCByOpcodeMx(0x13);     
}

void ora13mx() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY16());
    ORA16(data);

    updateCyclesByOpcodemx(0x13);
    updatePCByOpcodemx(0x13);
}

/* PEA - Push effective absolute address */
/* 0xF4 */
void peaF4() {
    u16 data = memRead16NoTrap(amAbsolute());
    PEA(data);

    updateCyclesByOpcodemx(0xF4);
    updatePCByOpcodemx(0xF4);
}

/* PEI - Push effective indirect address */
/* 0xD4 */
void peiD4() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    PEA(data);

    updateCyclesByOpcodemx(0xD4);
    updatePCByOpcodemx(0xD4);
}

/* PER - Push effective PC-relative indirect address */
/* 0x62 */
void per62() {
    s16 data = memRead16NoTrap(amAbsolute());
    PEA(data);

    updateCyclesByOpcodemx(0x62);
    updatePCByOpcodemx(0x62);
}

/* PHA - Push accumulator */
/* 0x48 */
void pha48M() {
    PHA8();

    updateCyclesByOpcodemx(0x48);
    updatePCByOpcodemx(0x48);
}

void pha48m() {
    PHA16();

    updateCyclesByOpcodemx(0x48);
    updatePCByOpcodemx(0x48);
}

/* PHB - Push data bank register */
/* 0x8B */
void phb8B() {
    PHB();

    updateCyclesByOpcodemx(0x8B);
    updatePCByOpcodemx(0x8B);
}

/* PHD - Push direct page register */
/* 0x0B */
void phd0B() {
    PHD();

    updateCyclesByOpcodemx(0x0B);
    updatePCByOpcodemx(0x0B);
}

/* PHK - Push program bank register */
/* 0x4B */
void phk4B() {
    PHK();

    updateCyclesByOpcodemx(0x4B);
    updatePCByOpcodemx(0x4B);
}

/* PHP - Push processor status register */
/* 0x08 */
void php08() {
    PHP();

    updateCyclesByOpcodemx(0x08);
    updatePCByOpcodemx(0x08);
}

/* PHX - Push index register X */
/* 0xDA */
void phxDAX() {
    PHX8();

    updateCyclesByOpcodeMX(0xDA);
    updatePCByOpcodeMX(0xDA);
}

void phxDAx() {
    PHX16();

    updateCyclesByOpcodemx(0xDA);
    updatePCByOpcodemx(0xDA);
}

/* PHY - Push index register Y */
/* 0x5A */
void phy5AX() {
    PHY8();

    updateCyclesByOpcodeMX(0x5A);
    updatePCByOpcodeMX(0x5A);
}

void phy5Ax() {
    PHY16();

    updateCyclesByOpcodemx(0x5A);
    updatePCByOpcodemx(0x5A);
}

/* PLA - Pull accumulator */
/* 0x68 */
void pla68M() {
   PLA8();

    updateCyclesByOpcodeMX(0x68);
    updatePCByOpcodeMX(0x68);
}

void pla68m() {
    PLA16();

    updateCyclesByOpcodemx(0x68);
    updatePCByOpcodemx(0x68);
}

/* PLB - Pull data bank register */
/* 0xAB */
void plbAB() {
    PLB();

    updateCyclesByOpcodemx(0xAB);
    updatePCByOpcodemx(0xAB);
}

/* PLD - Pull direct page register */
/* 0x2B */
void pld2B() {
    PLD();

    updateCyclesByOpcodemx(0x2B);
    updatePCByOpcodemx(0x2B);
}

/* PLP - Pull status flags */
/* 0x28 */
void plp28() {
    PLP();

    updateCyclesByOpcodemx(0x28);
    updatePCByOpcodemx(0x28);
}

/* PLX - Pull index register X from stack */
/* 0xFA */
void plxFAX() {
    PLX8();

    updateCyclesByOpcodeMX(0xFA);
    updatePCByOpcodeMX(0xFA);    
}

void plxFAx() {
    PLX16();

    updateCyclesByOpcodemx(0xFA);
    updatePCByOpcodemx(0xFA);
}

/* PLY - Pull index register Y from stack */
/* 0x7A */
void ply7AX() {
    PLY8();

    updateCyclesByOpcodeMX(0x7A);
    updatePCByOpcodeMX(0x7A);
}

void ply7Ax() {
    PLY16();

    updateCyclesByOpcodemx(0x7A);
    updatePCByOpcodemx(0x7A);
}

/* REP - Reset status bits */
/* 0xC2 */
void repC2() {
    u8 data = (memRead8NoTrap(amImmediate()));
    REP(data);

    updateCyclesByOpcodemx(0xC2);
    updatePCByOpcodemx(0xC2);
}

/* ROL - Rotate memory or accumulator left */
/* 0x2A */
void rol2AM() {
    ROL8(&CPU.A.al);

    updateCyclesByOpcodeMX(0x2A);
    updatePCByOpcodeMX(0x2A);
}

void rol2Am() {
    ROL16(&CPU.A.ac);

    updateCyclesByOpcodemx(0x2A);
    updatePCByOpcodemx(0x2A);
}

/* 0x2E */
void rol2EM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    ROL8(data);

    updateCyclesByOpcodeMX(0x2E);
    updatePCByOpcodeMX(0x2E);    
}

void rol2Em() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    ROL16(data);

    updateCyclesByOpcodemx(0x2E);
    updatePCByOpcodemx(0x2E);   
}

/* 0x26 */
void rol26M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    ROL8(data);

    updateCyclesByOpcodeMX(0x26);
    updatePCByOpcodeMX(0x26);       
}

void rol26m() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    ROL16(data);

    updateCyclesByOpcodemx(0x2E);
    updatePCByOpcodemx(0x2E);   
}

/* 0x3E */
void rol3EMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    ROL8(data);

    updateCyclesByOpcodeMX(0x3E);
    updatePCByOpcodeMX(0x3E);       
}

void rol3EmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    ROL16(data);

    updateCyclesByOpcodemX(0x3E);
    updatePCByOpcodemX(0x3E);     
}

void rol3EMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    ROL8(data);

    updateCyclesByOpcodeMx(0x3E);
    updatePCByOpcodeMx(0x3E);     
}

void rol3Emx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    ROL16(data);

    updateCyclesByOpcodemx(0x3E);
    updatePCByOpcodemx(0x3E); 
}

/* 0x36 */
void rol36MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX8()));
    ROL8(data);

    updateCyclesByOpcodeMX(0x36);
    updatePCByOpcodeMX(0x36); 
}

void rol36mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX8()));
    ROL16(data);

    updateCyclesByOpcodemX(0x36);
    updatePCByOpcodemX(0x36);  
}

void rol36Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX16()));
    ROL8(data);

    updateCyclesByOpcodeMx(0x36);
    updatePCByOpcodeMx(0x36);     
}

void rol36mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    ROL16(data);

    updateCyclesByOpcodemx(0x36);
    updatePCByOpcodemx(0x36); 
}

/* ROR - Rotate memory or accumulator right */
/* 0x6A */
void ror6AM() {
    ROR8(&CPU.A.al);

    updateCyclesByOpcodeMX(0x6A);
    updatePCByOpcodeMX(0x6A); 
}

void ror6Am() {
    ROR16(&CPU.A.ac);

    updateCyclesByOpcodemx(0x6A);
    updatePCByOpcodemx(0x6A); 
}

/* 0x6E */
void ror6EM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    ROR8(data);

    updateCyclesByOpcodeMX(0x6E);
    updatePCByOpcodeMX(0x6E);     
}

void ror6Em() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    ROR16(data);

    updateCyclesByOpcodemx(0x6E);
    updatePCByOpcodemx(0x6E); 
}

/* 0x66 */
void ror66M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    ROR8(data);

    updateCyclesByOpcodeMX(0x66);
    updatePCByOpcodeMX(0x66);        
}

void ror66m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    ROR16(data);

    updateCyclesByOpcodemx(0x66);
    updatePCByOpcodemx(0x66); 
}

/* 0x7E */
void ror7EMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    ROR8(data);

    updateCyclesByOpcodeMX(0x7E);
    updatePCByOpcodeMX(0x7E);    
}

void ror7EmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    ROR16(data);

    updateCyclesByOpcodemX(0x7E);
    updatePCByOpcodemX(0x7E);     
}

void ror7EMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    ROR8(data);

    updateCyclesByOpcodeMx(0x7E);
    updatePCByOpcodeMx(0x7E);     
}

void ror7Emx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    ROR16(data);

    updateCyclesByOpcodemx(0x7E);
    updatePCByOpcodemx(0x7E); 
}

/* 0x76 */
void ror76MX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    ROR8(data);

    updateCyclesByOpcodeMX(0x76);
    updatePCByOpcodeMX(0x76);     
}

void ror76mX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    ROR16(data);

    updateCyclesByOpcodemX(0x76);
    updatePCByOpcodemX(0x76);       
}

void ror76Mx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    ROR8(data);

    updateCyclesByOpcodeMx(0x76);
    updatePCByOpcodeMx(0x76);       
}

void ror76mx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    ROR16(data);

    updateCyclesByOpcodemx(0x76);
    updatePCByOpcodemx(0x76);   
}

/* RTI - Return from interrupt */
/* 0x40 */
void rti40() {
    RTI();

    updateCyclesByOpcodeMX(0x40);
    updatePCByOpcodeMX(0x40);   
}

/* RTL - Return from subroutine long */
/* 0x6B */
void rtl6B() {
    RTL();

    updateCyclesByOpcodeMX(0x6B);
    updatePCByOpcodeMX(0x6B); 
}

/* RTS - Return from subroutine */
/* 0x60 */
void rts60() {
    RTS();

    updateCyclesByOpcodeMX(0x60);
    updatePCByOpcodeMX(0x60); 
}

/* SBC - Subtract with borrow from accumulator */
/* 0xE9 */
void sbcE9M() {
    u8 data = memRead8NoTrap(amImmediate());
    SBC8(data);

    updateCyclesByOpcodeMX(0xE9);
    updatePCByOpcodeMX(0xE9);
}

void sbcE9m() {
    u16 data = memRead16NoTrap(amImmediate());
    SBC16(data);

    updateCyclesByOpcodemx(0xE9);
    updatePCByOpcodemx(0xE9);
}

/* 0xED */
void sbcEDM() {
    u8 data = memRead8NoTrap(amAbsolute());
    SBC8(data);

    updateCyclesByOpcodeMX(0xED);
    updatePCByOpcodeMX(0xED);    
}

void sbcEDm() {
    u16 data = memRead16NoTrap(amAbsolute());
    SBC16(data);

    updateCyclesByOpcodemx(0xE9);
    updatePCByOpcodemx(0xE9);
}

/* 0xEF */
void sbcEFM() {
    u8 data = memRead8NoTrap(amAbsoluteLong());
    SBC8(data);

    updateCyclesByOpcodeMX(0xEF);
    updatePCByOpcodeMX(0xEF);    
}

void sbcEFm() {
    u16 data = memRead16NoTrap(amAbsoluteLong());
    SBC16(data);

    updateCyclesByOpcodemx(0xEF);
    updatePCByOpcodemx(0xEF);
}

/* 0xE5 */
void sbcE5M() {
    u8 data = memRead8NoTrap(amDirectPage());
    SBC8(data);

    updateCyclesByOpcodeMX(0xE5);
    updatePCByOpcodeMX(0xE5);    
}

void sbcE5m() {
    u16 data = memRead16NoTrap(amDirectPage());
    SBC16(data);

    updateCyclesByOpcodemx(0xE5);
    updatePCByOpcodemx(0xE5);
}

/* 0xF2 */
void sbcF2M() {
    u8 data = memRead8NoTrap(amDirectPageIndirect());
    SBC8(data);

    updateCyclesByOpcodeMX(0xF2);
    updatePCByOpcodeMX(0xF2);    
}

void sbcF2m() {
    u16 data = memRead16NoTrap(amDirectPageIndirect());
    SBC16(data);

    updateCyclesByOpcodemx(0xF2);
    updatePCByOpcodemx(0xF2);
}

/* 0xE7 */
void sbcE7M() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLong());
    SBC8(data);

    updateCyclesByOpcodeMX(0xE7);
    updatePCByOpcodeMX(0xE7);    
}

void sbcE7m() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLong());
    SBC16(data);

    updateCyclesByOpcodemx(0xE7);
    updatePCByOpcodemx(0xE7);
}

/* 0xFD */
void sbcFDMX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xFD);
    updatePCByOpcodeMX(0xFD);    
}

void sbcFDmX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX8());
    SBC16(data);

    updateCyclesByOpcodemX(0xFD);
    updatePCByOpcodemX(0xFD);     
}

void sbcFDMx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexX16());
    SBC8(data);

    updateCyclesByOpcodeMx(0xFD);
    updatePCByOpcodeMx(0xFD);     
}

void sbcFDmx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexX16());
    SBC16(data);

    updateCyclesByOpcodemx(0xFD);
    updatePCByOpcodemx(0xFD); 
}

/* 0xFF */
void sbcFFMX() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xFF);
    updatePCByOpcodeMX(0xFF); 
}

void sbcFFmX() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX8());
    SBC16(data);

    updateCyclesByOpcodemX(0xFF);
    updatePCByOpcodemX(0xFF);     
}

void sbcFFMx() {
    u8 data = memRead8NoTrap(amAbsoluteLongIndexX16());
    SBC8(data);

    updateCyclesByOpcodeMx(0xFF);
    updatePCByOpcodeMx(0xFF);     
}

void sbcFFmx() {
    u16 data = memRead16NoTrap(amAbsoluteLongIndexX16());
    SBC16(data);

    updateCyclesByOpcodemx(0xFF);
    updatePCByOpcodemx(0xFF); 
}

/* 0xF9 */
void sbcF9MX() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xF9);
    updatePCByOpcodeMX(0xF9);     
}

void sbcF9mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    SBC16(data);

    updateCyclesByOpcodemX(0xF9);
    updatePCByOpcodemX(0xF9);     
}

void sbcF9Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    SBC8(data);

    updateCyclesByOpcodeMx(0xF9);
    updatePCByOpcodeMx(0xF9);     
}

void sbcF9mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    SBC16(data);

    updateCyclesByOpcodemx(0xF9);
    updatePCByOpcodemx(0xF9); 
}

/* 0xF5 */
void sbcF5MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexY8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xF5);
    updatePCByOpcodeMX(0xF5);     
}

void sbcF5mX() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY8());
    SBC16(data);

    updateCyclesByOpcodemX(0xF5);
    updatePCByOpcodemX(0xF5);      
}

void sbcF5Mx() {
    u8 data = memRead8NoTrap(amAbsoluteIndexY16());
    SBC8(data);

    updateCyclesByOpcodeMx(0xF5);
    updatePCByOpcodeMx(0xF5);    
}

void sbcF5mx() {
    u16 data = memRead16NoTrap(amAbsoluteIndexY16());
    SBC16(data);

    updateCyclesByOpcodemx(0xF5);
    updatePCByOpcodemx(0xF5);
}

/* 0xE1 */
void sbcE1MX() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xE1);
    updatePCByOpcodeMX(0xE1);    
}

void sbcE1mX() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX8());
    SBC16(data);

    updateCyclesByOpcodemX(0xE1);
    updatePCByOpcodemX(0xE1);     
}

void sbcE1Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndexIndirectX16());
    SBC8(data);

    updateCyclesByOpcodeMX(0xE1);
    updatePCByOpcodeMX(0xE1);     
}

void sbcE1mx() {
    u16 data = memRead16NoTrap(amDirectPageIndexIndirectX16());
    SBC16(data);

    updateCyclesByOpcodemx(0xE1);
    updatePCByOpcodemx(0xE1); 
}

/* 0xF1 */
void sbcF1MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xF1);
    updatePCByOpcodeMX(0xF1);     
}

void sbcF1mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY8());
    SBC16(data);

    updateCyclesByOpcodemX(0xF1);
    updatePCByOpcodemX(0xF1);    
}

void sbcF1Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectIndexY16());
    SBC8(data);

    updateCyclesByOpcodeMx(0xF1);
    updatePCByOpcodeMx(0xF1);
}

void sbcF1mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectIndexY16());
    SBC16(data);

    updateCyclesByOpcodemx(0xF1);
    updatePCByOpcodemx(0xF1);
}

/* 0xF7 */
void sbcF7MX() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xF7);
    updatePCByOpcodeMX(0xF7);    
}

void sbcF7mX() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY8());
    SBC16(data);

    updateCyclesByOpcodemX(0xF7);
    updatePCByOpcodemX(0xF7);      
}

void sbcF7Mx() {
    u8 data = memRead8NoTrap(amDirectPageIndirectLongIndexY16());
    SBC8(data);

    updateCyclesByOpcodeMx(0xF7);
    updatePCByOpcodeMx(0xF7);      
}

void sbcF7mx() {
    u16 data = memRead16NoTrap(amDirectPageIndirectLongIndexY16());
    SBC16(data);

    updateCyclesByOpcodemx(0xF7);
    updatePCByOpcodemx(0xF7);  
}

/* 0xE3 */
void sbcE3M() {
    u8 data = memRead8NoTrap(amStackRelative());
    SBC8(data);

    updateCyclesByOpcodeMX(0xE3);
    updatePCByOpcodeMX(0xE3);      
}

void sbcE3m() {
    u16 data = memRead16NoTrap(amStackRelative());
    SBC16(data);

    updateCyclesByOpcodemx(0xE3);
    updatePCByOpcodemx(0xE3);
}

/* 0xF3 */
void sbcF3MX() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY8());
    SBC8(data);

    updateCyclesByOpcodeMX(0xF3);
    updatePCByOpcodeMX(0xF3);    
}

void sbcF3mX() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY8());
    SBC16(data);

    updateCyclesByOpcodemX(0xF3);
    updatePCByOpcodemX(0xF3);      
}

void sbcF3Mx() {
    u8 data = memRead8NoTrap(amStackRelativeIndirectIndexY16());
    SBC8(data);

    updateCyclesByOpcodeMx(0xF3);
    updatePCByOpcodeMx(0xF3);      
}

void sbcF3mx() {
    u16 data = memRead16NoTrap(amStackRelativeIndirectIndexY16());
    SBC16(data);

    updateCyclesByOpcodemx(0xF3);
    updatePCByOpcodemx(0xF3);  
}

/* SEC - Set carry flag */
/* 0x38 */
void sec38() {
    SEC();

    updateCyclesByOpcodemx(0x38);
    updatePCByOpcodemx(0x38); 
}

/* SED - Set decimal mode flag */
/* 0xF8 */
void sedF8() {
    SED();

    updateCyclesByOpcodemx(0xF8);
    updatePCByOpcodemx(0xF8); 
}

/* SEI - Set interrupt disable flag */
/* 0x78 */
void sei78() {
    SEI();

    updateCyclesByOpcodemx(0x78);
    updatePCByOpcodemx(0x78); 
}

/* SEP - Set status bits */
/* 0xE2 */
void sepE2() {
    u8 data = memRead8NoTrap(amImmediate());
    SEP(data);

    updateCyclesByOpcodemx(0xE2);
    updatePCByOpcodemx(0xE2); 
}

/* STA - Store accumulator to memory */
/* 0x8D */
void sta8DM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    STA8(data);

    updateCyclesByOpcodeMX(0x8D);
    updatePCByOpcodeMX(0x8D);
}

void sta8Dm() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    STA16(data);

    updateCyclesByOpcodemx(0x8D);
    updatePCByOpcodemx(0x8D);
}

/* 0x8F */
void sta8FM() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteLong()));
    STA8(data);

    updateCyclesByOpcodeMX(0x8F);
    updatePCByOpcodeMX(0x8F);    
}

void sta8Fm() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteLong()));
    STA16(data);

    updateCyclesByOpcodemx(0x8D);
    updatePCByOpcodemx(0x8D);
}

/* 0x85 */
void sta85M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    STA8(data);

    updateCyclesByOpcodeMX(0x85);
    updatePCByOpcodeMX(0x85);    
}

void sta85m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    STA16(data);

    updateCyclesByOpcodemx(0x85);
    updatePCByOpcodemx(0x85); 
}

/* 0x92 */
void sta92M() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndirect()));
    STA8(data);

    updateCyclesByOpcodeMX(0x92);
    updatePCByOpcodeMX(0x92);     
}

void sta92m() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndirect()));
    STA16(data);

    updateCyclesByOpcodemx(0x85);
    updatePCByOpcodemx(0x85); 
}

/* 0x87 */
void sta87M() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndirectLong()));
    STA8(data);

    updateCyclesByOpcodeMX(0x87);
    updatePCByOpcodeMX(0x87);    
}

void sta87m() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndirectLong()));
    STA16(data);

    updateCyclesByOpcodemx(0x87);
    updatePCByOpcodemx(0x87);
}

/* 0x9D */
void sta9DMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x9D);
    updatePCByOpcodeMX(0x9D);    
}

void sta9DmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    STA16(data);

    updateCyclesByOpcodemX(0x9D);
    updatePCByOpcodemX(0x9D);      
}

void sta9DMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x9D);
    updatePCByOpcodeMx(0x9D);      
}

void sta9Dmx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    STA16(data);

    updateCyclesByOpcodemx(0x9D);
    updatePCByOpcodemx(0x9D);  
}

/* 0x9F */
void sta9FMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteLongIndexX8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x9F);
    updatePCByOpcodeMX(0x9F);      
}

void sta9FmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteLongIndexX8()));
    STA16(data);

    updateCyclesByOpcodemX(0x9F);
    updatePCByOpcodemX(0x9F);    
}

void sta9FMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteLongIndexX16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x9F);
    updatePCByOpcodeMx(0x9F);     
}

void sta9Fmx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteLongIndexX16()));
    STA16(data);

    updateCyclesByOpcodemx(0x9F);
    updatePCByOpcodemx(0x9F); 
}

/* 0x99 */
void sta99MX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexY8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x99);
    updatePCByOpcodeMX(0x99);     
}

void sta99mX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexY8()));
    STA16(data);

    updateCyclesByOpcodemX(0x99);
    updatePCByOpcodemX(0x99);    
}

void sta99Mx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexY16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x99);
    updatePCByOpcodeMx(0x99);    
}

void sta99mx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexY16()));
    STA16(data);

    updateCyclesByOpcodemx(0x99);
    updatePCByOpcodemx(0x99);
}

/* 0x95 */
void sta95MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x95);
    updatePCByOpcodeMX(0x95);    
}

void sta95mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX8()));
    STA16(data);

    updateCyclesByOpcodemX(0x95);
    updatePCByOpcodemX(0x95);     
}

void sta95Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x95);
    updatePCByOpcodeMx(0x95);     
}

void sta95mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    STA16(data);

    updateCyclesByOpcodemx(0x95);
    updatePCByOpcodemx(0x95); 
}

/* 0x81 */
void sta81MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexIndirectX8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x81);
    updatePCByOpcodeMX(0x81);     
}

void sta81mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX8()));
    STA16(data);

    updateCyclesByOpcodemX(0x81);
    updatePCByOpcodemX(0x81);     
}

void sta81Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x81);
    updatePCByOpcodeMx(0x81);     
}

void sta81mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    STA16(data);

    updateCyclesByOpcodemx(0x81);
    updatePCByOpcodemx(0x81); 
}

/* 0x91 */
void sta91MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndirectIndexY8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x91);
    updatePCByOpcodeMX(0x91);     
}

void sta91mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndirectIndexY8()));
    STA16(data);

    updateCyclesByOpcodemX(0x91);
    updatePCByOpcodemX(0x91);    
}

void sta91Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndirectIndexY16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x91);
    updatePCByOpcodeMx(0x91);    
}

void sta91mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndirectIndexY16()));
    STA16(data);

    updateCyclesByOpcodemx(0x91);
    updatePCByOpcodemx(0x91);
}

/* 0x97 */
void sta97MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndirectLongIndexY8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x97);
    updatePCByOpcodeMX(0x97);
}

void sta97mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndirectLongIndexY8()));
    STA16(data);

    updateCyclesByOpcodemX(0x97);
    updatePCByOpcodemX(0x97);    
}

void sta97Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndirectLongIndexY16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x97);
    updatePCByOpcodeMx(0x97);    
}

void sta97mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndirectLongIndexY16()));
    STA16(data);

    updateCyclesByOpcodemx(0x97);
    updatePCByOpcodemx(0x97);
}

/* 0x83 */
void sta83M() {
    u8* data = (u8*)(GETADDRESS(amStackRelative()));
    STA8(data);

    updateCyclesByOpcodeMX(0x83);
    updatePCByOpcodeMX(0x83);    
}

void sta83m() {
    u16* data = (u16*)(GETADDRESS(amStackRelative()));
    STA16(data);

    updateCyclesByOpcodemx(0x83);
    updatePCByOpcodemx(0x83);
}

/* 0x93 */
void sta93MX() {
    u8* data = (u8*)(GETADDRESS(amStackRelativeIndirectIndexY8()));
    STA8(data);

    updateCyclesByOpcodeMX(0x93);
    updatePCByOpcodeMX(0x93);    
}

void sta93mX() {
    u16* data = (u16*)(GETADDRESS(amStackRelativeIndirectIndexY8()));
    STA16(data);

    updateCyclesByOpcodemX(0x93);
    updatePCByOpcodemX(0x93);     
}

void sta93Mx() {
    u8* data = (u8*)(GETADDRESS(amStackRelativeIndirectIndexY16()));
    STA8(data);

    updateCyclesByOpcodeMx(0x93);
    updatePCByOpcodeMx(0x93);     
}

void sta93mx() {
    u16* data = (u16*)(GETADDRESS(amStackRelativeIndirectIndexY16()));
    STA16(data);

    updateCyclesByOpcodemx(0x93);
    updatePCByOpcodemx(0x93); 
}

/* STP - Stop the processor */
void stpDB() {
    STP();
}

/* STX - Store index register X to memory */
/* 0x8E */
void stx8EX() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    STX8(data);

    updateCyclesByOpcodeMX(0x8E);
    updatePCByOpcodeMX(0x8E);         
}

void stx8Ex() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    STX16(data);

    updateCyclesByOpcodemx(0x8E);
    updatePCByOpcodemx(0x8E); 
}

/* 0x86 */
void stx86X() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    STX8(data);

    updateCyclesByOpcodeMX(0x8E);
    updatePCByOpcodeMX(0x8E);     
}

void stx86x() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    STX16(data);

    updateCyclesByOpcodemx(0x8E);
    updatePCByOpcodemx(0x8E);    
}

/* 0x96 */
void stx96X() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexY8()));
    STX8(data);

    updateCyclesByOpcodeMX(0x96);
    updatePCByOpcodeMX(0x96);      
}

void stx96x() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexY16()));
    STX16(data);

    updateCyclesByOpcodemx(0x96);
    updatePCByOpcodemx(0x96); 
}

/* STY - Store index register Y to memory */
/* 0x8C */
void sty8CX() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    STY8(data);

    updateCyclesByOpcodeMX(0x8C);
    updatePCByOpcodeMX(0x8C);     
}

void sty8Cx() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    STY16(data);

    updateCyclesByOpcodemx(0x8C);
    updatePCByOpcodemx(0x8C); 
}

/* 0x84 */
void sty84X() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    STY8(data);

    updateCyclesByOpcodeMX(0x84);
    updatePCByOpcodeMX(0x84);     
}

void sty84x() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    STY16(data);

    updateCyclesByOpcodemx(0x84);
    updatePCByOpcodemx(0x84); 
}

/* 0x94 */
void sty94X() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX8()));
    STY8(data);

    updateCyclesByOpcodeMX(0x94);
    updatePCByOpcodeMX(0x94);     
}

void sty94x() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    STY16(data);

    updateCyclesByOpcodemx(0x94);
    updatePCByOpcodemx(0x94); 
}

/* STZ - Store zero to memory */
void stz9CM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    STZ8(data);

    updateCyclesByOpcodeMX(0x9C);
    updatePCByOpcodeMX(0x9C);     
}

void stz9Cm() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    STZ16(data);

    updateCyclesByOpcodemx(0x9C);
    updatePCByOpcodemx(0x9C);  
}
/* 0x64 */
void stz64M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    STZ8(data);

    updateCyclesByOpcodeMX(0x64);
    updatePCByOpcodeMX(0x64);      
}

void stz64m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    STZ16(data);

    updateCyclesByOpcodemx(0x64);
    updatePCByOpcodemx(0x64);  
}

/* 0x9E */
void stz9EMX() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX8()));
    STZ8(data);

    updateCyclesByOpcodeMX(0x9E);
    updatePCByOpcodeMX(0x9E);      
}

void stz9EmX() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX8()));
    STZ16(data);

    updateCyclesByOpcodemX(0x9E);
    updatePCByOpcodemX(0x9E);     
}

void stz9EMx() {
    u8* data = (u8*)(GETADDRESS(amAbsoluteIndexX16()));
    STZ8(data);

    updateCyclesByOpcodeMx(0x9E);
    updatePCByOpcodeMx(0x9E);     
}

void stz9Emx() {
    u16* data = (u16*)(GETADDRESS(amAbsoluteIndexX16()));
    STZ16(data);

    updateCyclesByOpcodemx(0x9E);
    updatePCByOpcodemx(0x9E); 
}

/* 0x74 */
void stz74MX() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX8()));
    STZ8(data);

    updateCyclesByOpcodeMX(0x74);
    updatePCByOpcodeMX(0x74);     
}

void stz74mX() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX8()));
    STZ16(data);

    updateCyclesByOpcodemX(0x74);
    updatePCByOpcodemX(0x74);         
}

void stz74Mx() {
    u8* data = (u8*)(GETADDRESS(amDirectPageIndexX16()));
    STZ8(data);

    updateCyclesByOpcodeMx(0x74);
    updatePCByOpcodeMx(0x74);         
}

void stz74mx() {
    u16* data = (u16*)(GETADDRESS(amDirectPageIndexX16()));
    STZ16(data);

    updateCyclesByOpcodemx(0x74);
    updatePCByOpcodemx(0x74);     
}

/* TAX - Transfer accumulator to index register X */
/* 0xAA */
void taxAAX() {
    TAX8();

    updateCyclesByOpcodeMX(0xAA);
    updatePCByOpcodeMX(0xAA);         
}

void taxAAx() {
    TAX16();

    updateCyclesByOpcodemx(0xAA);
    updatePCByOpcodemx(0xAA);        
}

/* TAY - Transfer accumulator to index register Y */
void tayA8X() {
    TAY8();

    updateCyclesByOpcodeMX(0xA8);
    updatePCByOpcodeMX(0xA8);         
}

void tayA8x() {
    TAY16();

    updateCyclesByOpcodemx(0xA8);
    updatePCByOpcodemx(0xA8);    
}

/* TCD - Transfer 16-bit accumulator to direct page register */
/* 0x5B */
void tcd5B() {
    TCD();

    updateCyclesByOpcodeMX(0x5B);
    updatePCByOpcodeMX(0x5B);    
}

/* TCS - Transfer accumulator to stack pointer */
/* 0x1B */
void tcs1B() {
    TCS();

    updateCyclesByOpcodeMX(0x1B);
    updatePCByOpcodeMX(0x1B);    
}

/* TDC - Transfer direct page register to 16-bit accumulator */
/* 0x7B */
void tdc7B() {
    TDC();

    updateCyclesByOpcodeMX(0x7B);
    updatePCByOpcodeMX(0x7B);    
}

/* TRB - Test and reset memory bits against accumulator */
/* 0x1C */
void trb1CM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    TRB8(data);

    updateCyclesByOpcodeMX(0x1C);
    updatePCByOpcodeMX(0x1C);        
}

void trb1Cm() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    TRB16(data);

    updateCyclesByOpcodemx(0x1C);
    updatePCByOpcodemx(0x1C);  
}

/* 0x14 */
void trb14M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    TRB8(data);

    updateCyclesByOpcodeMX(0x14);
    updatePCByOpcodeMX(0x14);      
}

void trb14m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    TRB16(data);

    updateCyclesByOpcodemx(0x14);
    updatePCByOpcodemx(0x14);
}

/* TSB - Test and set memory bits against accumulator */
/* 0x0C */
void tsb0CM() {
    u8* data = (u8*)(GETADDRESS(amAbsolute()));
    TSB8(data);

    updateCyclesByOpcodeMX(0x0C);
    updatePCByOpcodeMX(0x0C);  
}

void tsb0Cm() {
    u16* data = (u16*)(GETADDRESS(amAbsolute()));
    TSB16(data);

    updateCyclesByOpcodemx(0x0C);
    updatePCByOpcodemx(0x0C); 
}

/* 0x04 */
void tsb04M() {
    u8* data = (u8*)(GETADDRESS(amDirectPage()));
    TSB8(data);

    updateCyclesByOpcodeMX(0x04);
    updatePCByOpcodeMX(0x04);     
}

void tsb04m() {
    u16* data = (u16*)(GETADDRESS(amDirectPage()));
    TSB16(data);

    updateCyclesByOpcodemx(0x04);
    updatePCByOpcodemx(0x04); 
}

/* TSC - Transfer stack pointer to 16-bits accumulator */
/* 0x3B */
void tsc3B() {
    u8 data = memRead8NoTrap(amDirectPage());
    TSC();

    updateCyclesByOpcodeMX(0x3B);
    updatePCByOpcodeMX(0x3B); 
}

/* TSX - Transfer stack pointer to index register X */
/* 0xBA */
void tsxBAX() {
    TSX8();

    updateCyclesByOpcodeMX(0xBA);
    updatePCByOpcodeMX(0xBA);     
}

void tsxBAx() {
    TSX16();

    updateCyclesByOpcodemx(0xBA);
    updatePCByOpcodemx(0xBA); 
}

/* TXA - Transfer index register X to accumulator */
/* 0x8A */
void txa8AM() {
    TXA8();

    updateCyclesByOpcodeMX(0x8A);
    updatePCByOpcodeMX(0x8A);     
}

void txa8Am() {
    TXA16();

    updateCyclesByOpcodemx(0x8A);
    updatePCByOpcodemx(0x8A);     
}


/* TXS - Transfer index register X to stack pointer */
/* 0x9A */
void txs9AX() {
    TXS8();

    updateCyclesByOpcodeMX(0x9A);
    updatePCByOpcodeMX(0x9A);     
}

void txs9Ax() {
    TXS16();

    updateCyclesByOpcodemx(0x9A);
    updatePCByOpcodemx(0x9A); 
}

/* TXY - Transfer index register X to Y */
/* 0x9B */
void txy9BX() {
    TXY8();

    updateCyclesByOpcodeMX(0x9B);
    updatePCByOpcodeMX(0x9B); 
}

void txy9Bx() {
    TXY16();

    updateCyclesByOpcodemx(0x9B);
    updatePCByOpcodemx(0x9B); 
}

/* TYA - Transfer index register Y to accumulator */
/* 0x98 */
void tya98M() {
    TYA8();

    updateCyclesByOpcodeMX(0x98);
    updatePCByOpcodeMX(0x98);     
}

void tya98m() {
    TYA16();

    updateCyclesByOpcodemx(0x98);
    updatePCByOpcodemx(0x98);  
}

/* TYX - Transfer index register Y to X */
/* 0xBB */
void tyxBBX() {
    TYX8();

    updateCyclesByOpcodeMX(0xBB);
    updatePCByOpcodeMX(0xBB);
}

void tyxBBx() {
    TYX16();

    updateCyclesByOpcodemx(0xBB);
    updatePCByOpcodemx(0xBB);
}

/* WAI - Wait for interrupt */
/* 0xCB */
void waiCB() {
    WAI();

    updateCyclesByOpcodeMX(0xCB);
    updatePCByOpcodeMX(0xCB);  
}

/* WDM - Reserved for expansion; unused */
/* void wdm42(); */

/* XBA - Exchange the b and a accumulators */
/* 0xEB */
void xbaEB() {
    XBA();

    updateCyclesByOpcodeMX(0xEB);
    updatePCByOpcodeMX(0xEB);  
}

/* XCE - Exchange carry and emulation bit */
/* 0xFB */
void xceFB() {
    XCE();

    updateCyclesByOpcodeMX(0xFB);
    updatePCByOpcodeMX(0xFB);
}
